From c4f869f5746d48762d44e5ffc4c06e1a4a8f95dd Mon Sep 17 00:00:00 2001
From: Lorenzo Pacchiardi <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 3 Feb 2020 13:30:18 +0000
Subject: [PATCH 001/106] Update DefaultNN: training works for hidden layers as
 well, and can provide an optional different nonlinearity from ReLU

---
 abcpy/NN_utilities/networks.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/abcpy/NN_utilities/networks.py b/abcpy/NN_utilities/networks.py
index 72e80168..e58d8b68 100644
--- a/abcpy/NN_utilities/networks.py
+++ b/abcpy/NN_utilities/networks.py
@@ -41,15 +41,17 @@ def get_embedding(self, x):
         return self.embedding_net(x)
 
 
-def createDefaultNN(input_size, output_size, hidden_sizes=None):
+def createDefaultNN(input_size, output_size, hidden_sizes=None, nonlinearity=None):
     """Function returning a fully connected neural network class with a given input and output size, and optionally
     given hidden layer sizes (if these are not given, they are determined from the input and output size with some
     expression.
 
     In order to instantiate the network, you need to write: createDefaultNN(input_size, output_size)() as the function
     returns a class, and () is needed to instantiate an object."""
+
     class DefaultNN(nn.Module):
         """Neural network class with sizes determined by the upper level variables."""
+
         def __init__(self):
             super(DefaultNN, self).__init__()
             # put some fully connected layers:
@@ -70,7 +72,7 @@ def __init__(self):
                 self.fc_in = nn.Linear(input_size, hidden_sizes_list[0])
 
                 # define now the hidden layers
-                self.fc_hidden = []
+                self.fc_hidden = nn.ModuleList()
                 for i in range(len(hidden_sizes_list) - 1):
                     self.fc_hidden.append(nn.Linear(hidden_sizes_list[i], hidden_sizes_list[i + 1]))
                 self.fc_out = nn.Linear(hidden_sizes_list[-1], output_size)
@@ -80,12 +82,18 @@ def forward(self, x):
                            "fc_hidden"):  # it means that hidden sizes was provided and the length of the list was 0
                 return self.fc_in(x)
 
-            x = F.relu(self.fc_in(x))
-            for i in range(len(self.fc_hidden)):
-                x = F.relu(self.fc_hidden[i](x))
+            if nonlinearity is None:
+                x = F.relu(self.fc_in(x))
+                for i in range(len(self.fc_hidden)):
+                    x = F.relu(self.fc_hidden[i](x))
+            else:
+                x = nonlinearity(self.fc_in(x))
+                for i in range(len(self.fc_hidden)):
+                    x = nonlinearity(self.fc_hidden[i](x))
 
             x = self.fc_out(x)
 
             return x
 
     return DefaultNN
+

From 1ee41c9bba5095b5762c7a3524051dec4945ac98 Mon Sep 17 00:00:00 2001
From: statrita2004 <statrita2004@gmail.com>
Date: Fri, 6 Mar 2020 13:49:53 +0000
Subject: [PATCH 002/106] Fixing setup

---
 setup.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index 484774c4..1b4ad955 100644
--- a/setup.py
+++ b/setup.py
@@ -5,10 +5,16 @@
 
 try: # for pip >= 10
     from pip._internal.req import parse_requirements
-    from pip._internal.download import PipSession
 except ImportError: # for pip <= 9.0.3
     from pip.req import parse_requirements
-    from pip.download import PipSession
+    
+try: # for pip >= 19.3
+    from pip._internal.network.session import PipSession
+except ImportError: 
+    try: # for pip < 19.3 and >=10
+        from pip._internal.download import PipSession
+    except ImportError: # for pip <= 9.0.3
+        from pip.download import PipSession
 
 here = path.abspath(path.dirname(__file__))
 

From b7f788805a161721f66d551483ec4bb0690e87de Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 20 Mar 2020 09:37:56 +0100
Subject: [PATCH 003/106] Fix choice of GPU/CPU

---
 abcpy/statisticslearning.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 53fbb889..305018ae 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -292,13 +292,13 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
 
         if cuda is None:
             cuda = torch.cuda.is_available()
-        elif cuda and not torch.cuda.is_available:
+        elif cuda and not torch.cuda.is_available():
             # if the user requested to use GPU but no GPU is there
             cuda = False
             self.logger.warning(
                 "You requested to use GPU but no GPU is available! The computation will proceed on CPU.")
 
-        self.device = "cuda" if cuda and torch.cuda.is_available else "cpu"
+        self.device = "cuda" if cuda and torch.cuda.is_available() else "cpu"
         if self.device == "cuda":
             self.logger.debug("We are using GPU to train the network.")
         else:

From 38be318e9b77353ddaebb1d3a92bfe882312174a Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 22 Mar 2020 16:27:32 +0100
Subject: [PATCH 004/106] Add validation set and early stopping.

---
 abcpy/NN_utilities/algorithms.py |  73 ++++++--
 abcpy/NN_utilities/trainer.py    |  72 ++++++--
 abcpy/statisticslearning.py      | 287 ++++++++++++++++++++++++-------
 3 files changed, 347 insertions(+), 85 deletions(-)

diff --git a/abcpy/NN_utilities/algorithms.py b/abcpy/NN_utilities/algorithms.py
index 0df4305c..738be2f4 100644
--- a/abcpy/NN_utilities/algorithms.py
+++ b/abcpy/NN_utilities/algorithms.py
@@ -16,9 +16,10 @@
 
 
 def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_size=16, n_epochs=200,
-                         positive_weight=None, load_all_data_GPU=False, margin=1., lr=None, optimizer=None,
-                         scheduler=None, start_epoch=0, verbose=False, optimizer_kwargs={}, scheduler_kwargs={},
-                         loader_kwargs={}):
+                         samples_val=None, similarity_set_val=None, early_stopping=False, epochs_early_stopping_interval=1,
+                         start_epoch_early_stopping=10, positive_weight=None, load_all_data_GPU=False, margin=1.,
+                         lr=None, optimizer=None, scheduler=None, start_epoch_training=0,
+                         optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
     """ Implements the algorithm for the contrastive distance learning training of a neural network; need to be
      provided with a set of samples and the corresponding similarity matrix"""
 
@@ -33,6 +34,14 @@ def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_siz
     similarities_dataset = Similarities(samples, similarity_set, "cuda" if cuda and load_all_data_GPU else "cpu")
     pairs_dataset = SiameseSimilarities(similarities_dataset, positive_weight=positive_weight)
 
+    if (samples_val is None) != (similarity_set_val is None):
+        raise RuntimeError("val samples and similarity set need to be provided together.")
+
+    if samples_val is not None:
+        similarities_dataset_val = Similarities(samples_val, similarity_set_val,
+                                                 "cuda" if cuda and load_all_data_GPU else "cpu")
+        pairs_dataset_val = SiameseSimilarities(similarities_dataset_val, positive_weight=positive_weight)
+
     if cuda:
         if load_all_data_GPU:
             loader_kwargs_2 = {'num_workers': 0, 'pin_memory': False}
@@ -45,6 +54,11 @@ def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_siz
 
     pairs_train_loader = torch.utils.data.DataLoader(pairs_dataset, batch_size=batch_size, shuffle=True,
                                                      **loader_kwargs)
+    if samples_val is not None:
+        pairs_train_loader_val = torch.utils.data.DataLoader(pairs_dataset_val, batch_size=batch_size, shuffle=False,
+                                                              **loader_kwargs)
+    else:
+        pairs_train_loader_val = None
 
     model_contrastive = SiameseNet(embedding_net)
 
@@ -66,14 +80,20 @@ def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_siz
         scheduler = scheduler(optimizer, **scheduler_kwargs)
 
     # now train:
-    fit(pairs_train_loader, model_contrastive, loss_fn, optimizer, scheduler, n_epochs, cuda, start_epoch=start_epoch)
+    fit(pairs_train_loader, model_contrastive, loss_fn, optimizer, scheduler, n_epochs, cuda,
+        val_loader=pairs_train_loader_val,
+        early_stopping=early_stopping, start_epoch_early_stopping=start_epoch_early_stopping,
+        epochs_early_stopping_interval=epochs_early_stopping_interval, start_epoch_training=start_epoch_training)
 
     return embedding_net
 
 
 def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16, n_epochs=400,
-                     load_all_data_GPU=False, margin=1., lr=None, optimizer=None, scheduler=None, start_epoch=0,
-                     verbose=False, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
+                     samples_val=None, similarity_set_val=None, early_stopping=False, epochs_early_stopping_interval=1,
+                     start_epoch_early_stopping=10,
+                     load_all_data_GPU=False, margin=1., lr=None, optimizer=None, scheduler=None,
+                     start_epoch_training=0,
+                     optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
     """ Implements the algorithm for the triplet distance learning training of a neural network; need to be
      provided with a set of samples and the corresponding similarity matrix"""
 
@@ -87,6 +107,14 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
     similarities_dataset = Similarities(samples, similarity_set, "cuda" if cuda and load_all_data_GPU else "cpu")
     triplets_dataset = TripletSimilarities(similarities_dataset)
 
+    if (samples_val is None) != (similarity_set_val is None):
+        raise RuntimeError("val samples and similarity set need to be provided together.")
+
+    if samples_val is not None:
+        similarities_dataset_val = Similarities(samples_val, similarity_set_val,
+                                                 "cuda" if cuda and load_all_data_GPU else "cpu")
+        triplets_dataset_val = TripletSimilarities(similarities_dataset_val)
+
     if cuda:
         if load_all_data_GPU:
             loader_kwargs_2 = {'num_workers': 0, 'pin_memory': False}
@@ -99,6 +127,11 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
 
     triplets_train_loader = torch.utils.data.DataLoader(triplets_dataset, batch_size=batch_size, shuffle=True,
                                                         **loader_kwargs)
+    if samples_val is not None:
+        triplets_train_loader_val = torch.utils.data.DataLoader(triplets_dataset_val, batch_size=batch_size,
+                                                                 shuffle=False, **loader_kwargs)
+    else:
+        triplets_train_loader_val = None
 
     model_triplet = TripletNet(embedding_net)
 
@@ -120,13 +153,17 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
         scheduler = scheduler(optimizer, **scheduler_kwargs)
 
     # now train:
-    fit(triplets_train_loader, model_triplet, loss_fn, optimizer, scheduler, n_epochs, cuda, start_epoch=start_epoch)
+    fit(triplets_train_loader, model_triplet, loss_fn, optimizer, scheduler, n_epochs, cuda,
+        val_loader=triplets_train_loader_val,
+        early_stopping=early_stopping, start_epoch_early_stopping=start_epoch_early_stopping,
+        epochs_early_stopping_interval=epochs_early_stopping_interval, start_epoch_training=start_epoch_training)
 
     return embedding_net
 
 
-def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=50, load_all_data_GPU=False,
-                   lr=1e-3, optimizer=None, scheduler=None, start_epoch=0, verbose=False, optimizer_kwargs={},
+def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=50, samples_val=None, target_val=None,
+                   early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, load_all_data_GPU=False,
+                   lr=1e-3, optimizer=None, scheduler=None, start_epoch_training=0, optimizer_kwargs={},
                    scheduler_kwargs={}, loader_kwargs={}):
     """ Implements the algorithm for the training of a neural network based on regressing the values of the parameters
     on the corresponding simulation outcomes; it is effectively a training with a mean squared error loss. Needs to be
@@ -142,6 +179,13 @@ def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=
 
     dataset_FP_nn = ParameterSimulationPairs(samples, target, "cuda" if cuda and load_all_data_GPU else "cpu")
 
+    if (samples_val is None) != (target_val is None):
+        raise RuntimeError("val samples and similarity set need to be provided together.")
+
+    if samples_val is not None:
+        dataset_FP_nn_val = ParameterSimulationPairs(samples_val, target_val,
+                                                      "cuda" if cuda and load_all_data_GPU else "cpu")
+
     if cuda:
         if load_all_data_GPU:
             loader_kwargs_2 = {'num_workers': 0, 'pin_memory': False}
@@ -154,6 +198,12 @@ def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=
 
     data_loader_FP_nn = torch.utils.data.DataLoader(dataset_FP_nn, batch_size=batch_size, shuffle=True, **loader_kwargs)
 
+    if samples_val is not None:
+        data_loader_FP_nn_val = torch.utils.data.DataLoader(dataset_FP_nn_val, batch_size=batch_size,
+                                                             shuffle=False, **loader_kwargs)
+    else:
+        data_loader_FP_nn_val = None
+
     if cuda:
         embedding_net.cuda()
     loss_fn = nn.MSELoss(reduction="mean")
@@ -169,6 +219,9 @@ def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=
         scheduler = scheduler(optimizer, **scheduler_kwargs)
 
     # now train:
-    fit(data_loader_FP_nn, embedding_net, loss_fn, optimizer, scheduler, n_epochs, cuda, start_epoch=start_epoch)
+    fit(data_loader_FP_nn, embedding_net, loss_fn, optimizer, scheduler, n_epochs, cuda,
+        val_loader=data_loader_FP_nn_val,
+        early_stopping=early_stopping, start_epoch_early_stopping=start_epoch_early_stopping,
+        epochs_early_stopping_interval=epochs_early_stopping_interval, start_epoch_training=start_epoch_training)
 
     return embedding_net
diff --git a/abcpy/NN_utilities/trainer.py b/abcpy/NN_utilities/trainer.py
index dbcf9533..0e6bbfa6 100644
--- a/abcpy/NN_utilities/trainer.py
+++ b/abcpy/NN_utilities/trainer.py
@@ -1,8 +1,10 @@
 from tqdm import tqdm
 import logging
+import torch
 
 
-def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, start_epoch=0):
+def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_loader=None, early_stopping=False,
+        epochs_early_stopping_interval=1, start_epoch_early_stopping=10, start_epoch_training=0):
     """
     Basic function to train a neural network given a train_loader, a loss function and an optimizer.
 
@@ -17,18 +19,40 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, star
     """
 
     logger = logging.getLogger("NN Trainer")
+    if early_stopping and val_loader is not None:
+        validation_loss_list = []
+    if early_stopping and val_loader is None:
+        raise RuntimeError("You cannot perform early stopping if a validation loader is not provided to the training "
+                           "routine")
 
-    for epoch in range(0, start_epoch):
-        scheduler.step()
-
-    for epoch in tqdm(range(start_epoch, n_epochs)):
+    for epoch in range(0, start_epoch_training):
         scheduler.step()
 
+    for epoch in tqdm(range(start_epoch_training, n_epochs)):
         # Train stage
         train_loss = train_epoch(train_loader, model, loss_fn, optimizer, cuda)
 
         logger.debug('Epoch: {}/{}. Train set: Average loss: {:.4f}'.format(epoch + 1, n_epochs, train_loss))
 
+        # Validation stage
+        if val_loader is not None:
+            val_loss = test_epoch(val_loader, model, loss_fn, cuda)
+
+            logger.debug('Epoch: {}/{}. Validation set: Average loss: {:.4f}'.format(epoch + 1, n_epochs, val_loss))
+
+            # early stopping:
+            if early_stopping and (epoch + 1) % epochs_early_stopping_interval == 0:
+                validation_loss_list.append(val_loss)  # save the previous validation loss. It is actually
+                net_state_dict = model.state_dict()
+                # we need to have at least two saved test losses for performing early stopping.
+                if epoch + 1 >= start_epoch_early_stopping and len(validation_loss_list) > 1:
+                    if validation_loss_list[-1] > validation_loss_list[-2]:
+                        logger.info("Training has been early stopped at epoch {}.".format(epoch + 1))
+                        # reload the previous state dict:
+                        model.load_state_dict(net_state_dict)
+                        break  # stop training
+        scheduler.step()
+
 
 def train_epoch(train_loader, model, loss_fn, optimizer, cuda):
     """Function implementing the training in one epoch.
@@ -36,7 +60,6 @@ def train_epoch(train_loader, model, loss_fn, optimizer, cuda):
     Adapted from https://github.com/adambielski/siamese-triplet
     """
     model.train()
-    losses = []
     total_loss = 0
 
     for batch_idx, (data, target) in enumerate(train_loader):
@@ -61,12 +84,41 @@ def train_epoch(train_loader, model, loss_fn, optimizer, cuda):
 
         loss_outputs = loss_fn(*loss_inputs)
         loss = loss_outputs[0] if type(loss_outputs) in (tuple, list) else loss_outputs
-        losses.append(loss.item())
         total_loss += loss.item()
         loss.backward()
         optimizer.step()
 
-        losses = []
+    return total_loss / (batch_idx + 1)  # divide here by the number of elements in the batch.
+
+
+def test_epoch(val_loader, model, loss_fn, cuda):
+    """Function implementing the computation of the validation error, in batches.
+
+    Adapted from https://github.com/adambielski/siamese-triplet
+    """
+    with torch.no_grad():
+        model.eval()
+        val_loss = 0
+        for batch_idx, (data, target) in enumerate(val_loader):
+            target = target if len(target) > 0 else None
+            if not type(data) in (tuple, list):
+                data = (data,)
+            if cuda:
+                data = tuple(d.cuda() for d in data)
+                if target is not None:
+                    target = target.cuda()
+
+            outputs = model(*data)
+
+            if type(outputs) not in (tuple, list):
+                outputs = (outputs,)
+            loss_inputs = outputs
+            if target is not None:
+                target = (target,)
+                loss_inputs += target
+
+            loss_outputs = loss_fn(*loss_inputs)
+            loss = loss_outputs[0] if type(loss_outputs) in (tuple, list) else loss_outputs
+            val_loss += loss.item()
 
-    total_loss /= (batch_idx + 1)
-    return total_loss
+    return val_loss / (batch_idx + 1)  # divide here by the number of elements in the batch.
diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 305018ae..6a287b4a 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -1,6 +1,7 @@
 import logging
 from abc import ABCMeta, abstractmethod
 
+import numpy as np
 from sklearn import linear_model
 
 from abcpy.acceptedparametersmanager import *
@@ -28,8 +29,8 @@ class StatisticsLearning(metaclass=ABCMeta):
     """This abstract base class defines a way to choose the summary statistics.
     """
 
-    def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_per_param=1, parameters=None,
-                 simulations=None, seed=None):
+    def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_val=0, n_samples_per_param=1,
+                 parameters=None, simulations=None, parameters_val=None, simulations_val=None, seed=None):
 
         """The constructor of a sub-class must accept a non-optional model, statistics calculator and
         backend which are stored to self.model, self.statistics_calc and self.backend. Further it
@@ -53,23 +54,40 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
             The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot
             step. The default value is 1000.
             This is ignored if `simulations` and `parameters` are provided.
+        n_samples_val: int, optional
+            The number of (parameter, simulated data) tuple to be generated to be used as a validation set in the pilot
+            step. The default value is 0, which means no validation set is used.
+            This is ignored if `simulations_val` and `parameters_val` are provided.
         n_samples_per_param: int, optional
             Number of data points in each simulated data set. This is ignored if `simulations` and `parameters` are
             provided. Default to 1.
         parameters: array, optional
             A numpy array with shape (n_samples, n_parameters) that is used, together with `simulations` to fit the
             summary selection learning algorithm. It has to be provided together with `simulations`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
         simulations: array, optional
             A numpy array with shape (n_samples, output_size) that is used, together with `parameters` to fit the
             summary selection learning algorithm. It has to be provided together with `parameters`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
+        parameters_val: array, optional
+            A numpy array with shape (n_samples_val, n_parameters) that is used, together with `simulations_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `simulations_val`, in which case no other simulations are performed to generate the validation set. Default 
+            value is None.
+        simulations_val: array, optional
+            A numpy array with shape (n_samples_val, output_size) that is used, together with `parameters_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `parameters_val`, in which case no other simulations are performed to generate the validation set. Default
+            value is None.
         seed: integer, optional
             Optional initial seed for the random number generator. The default value is generated randomly.
         """
         if (parameters is None) != (simulations is None):
             raise RuntimeError("parameters and simulations need to be provided together.")
 
+        if (parameters_val is None) != (simulations_val is None):
+            raise RuntimeError("parameters_val and simulations_val need to be provided together.")
+
         self.model = model
         self.statistics_calc = statistics_calc
         self.backend = backend
@@ -77,7 +95,9 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
         self.n_samples_per_param = n_samples_per_param
         self.logger = logging.getLogger(__name__)
 
-        if parameters is None:  # then also simulations is None
+        n_samples_to_generate = n_samples * (parameters is None) + n_samples_val * (parameters_val is None)
+
+        if n_samples_to_generate > 0:  # need to generate some data 
             self.logger.info('Generation of data...')
 
             self.logger.debug("Definitions for parallelization.")
@@ -87,7 +107,8 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
 
             self.logger.debug("Map phase.")
             # main algorithm
-            seed_arr = self.rng.randint(1, n_samples * n_samples, size=n_samples, dtype=np.int32)
+            seed_arr = self.rng.randint(1, n_samples_to_generate * n_samples_to_generate, size=n_samples_to_generate,
+                                        dtype=np.int32)
             rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
             rng_pds = self.backend.parallelize(rng_arr)
 
@@ -101,24 +122,38 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
 
             self.logger.debug("Reshape data")
             # reshape the sample parameters; so that we can also work with multidimensional parameters
-            self.sample_parameters = sample_parameters.reshape((n_samples, -1))
+            self.sample_parameters = sample_parameters.reshape((n_samples_to_generate, -1))
 
             # now reshape the statistics in the case in which several n_samples_per_param > 1, and repeat the array with
             # the parameters so that the regression algorithms can work on the pair of arrays. Maybe there are smarter
             # ways of doing this.
 
-            self.sample_statistics = self.sample_statistics.reshape(n_samples * self.n_samples_per_param, -1)
-            self.sample_parameters = np.repeat(self.sample_parameters, self.n_samples_per_param, axis=0)
+            sample_statistics_generated = self.sample_statistics.reshape(
+                n_samples_to_generate * self.n_samples_per_param, -1)
+            sample_parameters_generated = np.repeat(self.sample_parameters, self.n_samples_per_param, axis=0)
+            # now split between train and validation set:
+            self.sample_statistics = sample_statistics_generated[
+                                     0: n_samples * self.n_samples_per_param * (parameters is None)]
+            self.sample_parameters = sample_parameters_generated[
+                                     0: n_samples * self.n_samples_per_param * (parameters is None)]
+
+            self.sample_statistics_val = sample_statistics_generated[
+                                         n_samples * self.n_samples_per_param * (parameters is None):len(
+                                             sample_statistics_generated)]
+            self.sample_parameters_val = sample_parameters_generated[
+                                         n_samples * self.n_samples_per_param * (parameters is None):len(
+                                             sample_parameters_generated)]
+
             self.logger.info('Data generation finished.')
 
-        else:
+        if parameters is not None:
             # do all the checks on dimensions:
             if not isinstance(parameters, np.ndarray) or not isinstance(simulations, np.ndarray):
                 raise TypeError("parameters and simulations need to be numpy arrays.")
             if len(parameters.shape) != 2:
                 raise RuntimeError("parameters have to be a 2-dimensional array")
             if len(simulations.shape) != 2:
-                raise RuntimeError("parameters have to be a 2-dimensional array")
+                raise RuntimeError("simulations have to be a 2-dimensional array")
             if simulations.shape[0] != parameters.shape[0]:
                 raise RuntimeError("parameters and simulations need to have the same first dimension")
 
@@ -129,6 +164,24 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
 
             self.logger.info("The statistics will be learned using the provided data and parameters")
 
+        if parameters_val is not None:
+            # do all the checks on dimensions:
+            if not isinstance(parameters_val, np.ndarray) or not isinstance(simulations_val, np.ndarray):
+                raise TypeError("parameters_val and simulations_val need to be numpy arrays.")
+            if len(parameters_val.shape) != 2:
+                raise RuntimeError("parameters_val have to be a 2-dimensional array")
+            if len(simulations_val.shape) != 2:
+                raise RuntimeError("simulations_val have to be a 2-dimensional array")
+            if simulations_val.shape[0] != parameters_val.shape[0]:
+                raise RuntimeError("parameters_val and simulations_val need to have the same first dimension")
+
+            # if all checks are passed:
+            self.sample_statistics_val = self.statistics_calc.statistics(
+                [simulations_val[i] for i in range(simulations_val.shape[0])])
+            self.sample_parameters_val = parameters_val
+
+            self.logger.info("The provided validation data and parameters will be used as a validation set.")
+
     def __getstate__(self):
         state = self.__dict__.copy()
         del state['backend']
@@ -222,6 +275,7 @@ def get_statistics(self):
         return LinearTransformation(np.transpose(self.coefficients_learnt), previous_statistics=self.statistics_calc)
 
 
+# TODO add scaler before applying the neural network ?
 class StatisticsLearningNN(StatisticsLearning, GraphTools):
     """This is the base class for all the statistics learning techniques involving neural networks. In most cases, you
     should not instantiate this directly. The actual classes instantiate this with the right arguments.
@@ -230,8 +284,9 @@ class StatisticsLearningNN(StatisticsLearning, GraphTools):
     """
 
     def __init__(self, model, statistics_calc, backend, training_routine, distance_learning, embedding_net=None,
-                 n_samples=1000, n_samples_per_param=1, parameters=None, simulations=None, seed=None, cuda=None,
-                 quantile=0.1, **training_routine_kwargs):
+                 n_samples=1000, n_samples_val=0, n_samples_per_param=1, parameters=None, simulations=None,
+                 parameters_val=None, simulations_val=None, seed=None, cuda=None, quantile=0.1,
+                 **training_routine_kwargs):
         """
         Parameters
         ----------
@@ -258,17 +313,31 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
             The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot
             step. The default value is 1000.
             This is ignored if `simulations` and `parameters` are provided.
+        n_samples_val: int, optional
+            The number of (parameter, simulated data) tuple to be generated to be used as a validation set in the pilot
+            step. The default value is 0, which means no validation set is used.
+            This is ignored if `simulations_val` and `parameters_val` are provided.
         n_samples_per_param: int, optional
             Number of data points in each simulated data set. This is ignored if `simulations` and `parameters` are
             provided. Default to 1.
         parameters: array, optional
             A numpy array with shape (n_samples, n_parameters) that is used, together with `simulations` to fit the
             summary selection learning algorithm. It has to be provided together with `simulations`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
         simulations: array, optional
             A numpy array with shape (n_samples, output_size) that is used, together with `parameters` to fit the
             summary selection learning algorithm. It has to be provided together with `parameters`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
+        parameters_val: array, optional
+            A numpy array with shape (n_samples_val, n_parameters) that is used, together with `simulations_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `simulations_val`, in which case no other simulations are performed to generate the validation set. Default 
+            value is None.
+        simulations_val: array, optional
+            A numpy array with shape (n_samples_val, output_size) that is used, together with `parameters_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `parameters_val`, in which case no other simulations are performed to generate the validation set. Default
+            value is None.
         seed: integer, optional
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
@@ -306,17 +375,29 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
 
         # this handles generation of the data (or its formatting in case the data is provided to the Semiautomatic
         # class)
-        super(StatisticsLearningNN, self).__init__(model, statistics_calc, backend, n_samples, n_samples_per_param,
-                                                   parameters, simulations, seed)
+        super(StatisticsLearningNN, self).__init__(model, statistics_calc, backend, n_samples, n_samples_val,
+                                                   n_samples_per_param, parameters, simulations, seed=seed,
+                                                   parameters_val=parameters_val, simulations_val=simulations_val)
+
+        # we have a validation set if it has the following attribute with size larger than 0
+        has_val_set = hasattr(self, "sample_parameters_val") and len(self.sample_parameters_val) > 0
 
         self.logger.info('Learning of the transformation...')
         # Define Data
-        target, simulations_reshaped = self.sample_parameters, self.sample_statistics
+        target, simulations = self.sample_parameters, self.sample_statistics
+        if has_val_set:
+            target_val, simulations_val = self.sample_parameters_val, self.sample_statistics_val
+        else:
+            target_val, simulations_val = None, None
 
         if distance_learning:
             self.logger.debug("Computing similarity matrix...")
             # define the similarity set
             similarity_set = compute_similarity_matrix(target, quantile)
+            if has_val_set:
+                similarity_set_val = compute_similarity_matrix(target_val, quantile)
+            else:
+                similarity_set_val = None
             self.logger.debug("Done")
 
         # now setup the default neural network or not
@@ -328,7 +409,7 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
         elif isinstance(embedding_net, list) or embedding_net is None:
             # therefore we need to generate the neural network given the list. The following function returns a class
             # of NN with given input size, output size and hidden sizes; then, need () to instantiate the network
-            self.embedding_net = createDefaultNN(input_size=simulations_reshaped.shape[1], output_size=target.shape[1],
+            self.embedding_net = createDefaultNN(input_size=simulations.shape[1], output_size=target.shape[1],
                                                  hidden_sizes=embedding_net)()
             self.logger.debug('We generate a default neural network')
 
@@ -338,12 +419,13 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
         self.logger.debug('We now run the training routine')
 
         if distance_learning:
-            self.embedding_net = training_routine(simulations_reshaped, similarity_set,
-                                                  embedding_net=self.embedding_net, cuda=cuda,
-                                                  **training_routine_kwargs)
+            self.embedding_net = training_routine(simulations, similarity_set, embedding_net=self.embedding_net,
+                                                  cuda=cuda, samples_val=simulations_val,
+                                                  similarity_set_val=similarity_set_val, **training_routine_kwargs)
         else:
-            self.embedding_net = training_routine(simulations_reshaped, target, embedding_net=self.embedding_net,
-                                                  cuda=cuda, **training_routine_kwargs)
+            self.embedding_net = training_routine(simulations, target, embedding_net=self.embedding_net,
+                                                  cuda=cuda, samples_val=simulations_val, target_val=target_val,
+                                                  **training_routine_kwargs)
 
         self.logger.info("Finished learning the transformation.")
 
@@ -371,10 +453,11 @@ class SemiautomaticNN(StatisticsLearningNN):
      computation via deep neural network. Statistica Sinica, pp.1595-1618.
     """
 
-    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_per_param=1,
-                 parameters=None, simulations=None, seed=None, cuda=None, batch_size=16, n_epochs=200,
-                 load_all_data_GPU=False, lr=1e-3, optimizer=None, scheduler=None, start_epoch=0, verbose=False,
-                 optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
+    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
+                 n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
+                 early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10,
+                 seed=None, cuda=None, batch_size=16, n_epochs=200, load_all_data_GPU=False, lr=1e-3, optimizer=None,
+                 scheduler=None, start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
         Parameters
         ----------
@@ -395,17 +478,43 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
             The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot
             step. The default value is 1000.
             This is ignored if `simulations` and `parameters` are provided.
+        n_samples_val: int, optional
+            The number of (parameter, simulated data) tuple to be generated to be used as a validation set in the pilot
+            step. The default value is 0, which means no validation set is used.
+            This is ignored if `simulations_val` and `parameters_val` are provided.
         n_samples_per_param: int, optional
             Number of data points in each simulated data set. This is ignored if `simulations` and `parameters` are
             provided. Default to 1.
         parameters: array, optional
             A numpy array with shape (n_samples, n_parameters) that is used, together with `simulations` to fit the
             summary selection learning algorithm. It has to be provided together with `simulations`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
         simulations: array, optional
             A numpy array with shape (n_samples, output_size) that is used, together with `parameters` to fit the
             summary selection learning algorithm. It has to be provided together with `parameters`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
+        parameters_val: array, optional
+            A numpy array with shape (n_samples_val, n_parameters) that is used, together with `simulations_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `simulations_val`, in which case no other simulations are performed to generate the validation set. Default 
+            value is None.
+        simulations_val: array, optional
+            A numpy array with shape (n_samples_val, output_size) that is used, together with `parameters_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `parameters_val`, in which case no other simulations are performed to generate the validation set. Default
+            value is None.
+        early_stopping: boolean, optional
+            If True, the validation set (which needs to be either provided through the arguments `parameters_val` and
+            `simulations_val` or generated by setting `n_samples_val` to a value larger than 0) is used to early stop
+            the training of the neural network as soon as the loss on the validation set starts to increase. Default
+            value is False.
+        epochs_early_stopping_interval: integer, optional
+            The frequency at which the validation error is compared in order to decide whether to early stop the
+            training or not. Namely, if `epochs_early_stopping_interval=10`, early stopping can happen only at epochs multiple of
+            10. Defaul value is 1.
+        start_epoch_early_stopping: integer, optional
+            The epoch after which early stopping can happen; in fact, as soon as training starts, there may be a 
+            transient period in which the loss increases. Default value is 10.
         seed: integer, optional
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
@@ -427,10 +536,10 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
         scheduler: torch _LRScheduler class, optional
             A torch _LRScheduler class, used to modify the learning rate across epochs. By default, no scheduler is
             used. Additional parameters may be passed through the `scheduler_kwargs` parameter.
-        start_epoch: integer, optional
-            If a scheduler is provided, for the first `start_epoch` epochs the scheduler is applied to modify the
-            learning rate without training the network. From then on, the training proceeds normally, applying both the
-            scheduler and the optimizer at each epoch. Default to 0.
+        start_epoch_training: integer, optional
+            If a scheduler is provided, for the first `start_epoch_training` epochs the scheduler is applied to modify
+            the learning rate without training the network. From then on, the training proceeds normally, applying both
+            the scheduler and the optimizer at each epoch. Default to 0.
         verbose: boolean, optional
             if True, prints more information from the training routine. Default to False.
         optimizer_kwargs: Python dictionary, optional
@@ -443,11 +552,17 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
         """
         super(SemiautomaticNN, self).__init__(model, statistics_calc, backend, FP_nn_training, distance_learning=False,
                                               embedding_net=embedding_net, n_samples=n_samples,
-                                              n_samples_per_param=n_samples_per_param, parameters=parameters,
-                                              simulations=simulations, seed=seed, cuda=cuda, batch_size=batch_size,
+                                              n_samples_val=n_samples_val, n_samples_per_param=n_samples_per_param,
+                                              parameters=parameters, simulations=simulations,
+                                              parameters_val=parameters_val, simulations_val=simulations_val,
+                                              early_stopping=early_stopping,
+                                              epochs_early_stopping_interval=epochs_early_stopping_interval,
+                                              start_epoch_early_stopping=start_epoch_early_stopping,
+                                              seed=seed, cuda=cuda, batch_size=batch_size,
                                               n_epochs=n_epochs, load_all_data_GPU=load_all_data_GPU, lr=lr,
-                                              optimizer=optimizer, scheduler=scheduler, start_epoch=start_epoch,
-                                              verbose=verbose, optimizer_kwargs=optimizer_kwargs,
+                                              optimizer=optimizer, scheduler=scheduler,
+                                              start_epoch_training=start_epoch_training,
+                                              optimizer_kwargs=optimizer_kwargs,
                                               scheduler_kwargs=scheduler_kwargs, loader_kwargs=loader_kwargs)
 
 
@@ -464,10 +579,12 @@ class TripletDistanceLearning(StatisticsLearningNN):
      Bayesian Computation To Model a Volcanic Eruption. arXiv preprint arXiv:1909.13118.
     """
 
-    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_per_param=1,
-                 parameters=None, simulations=None, seed=None, cuda=None, quantile=0.1, batch_size=16, n_epochs=200,
-                 load_all_data_GPU=False, margin=1., lr=None, optimizer=None, scheduler=None, start_epoch=0,
-                 verbose=False, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
+    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
+                 n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
+                 early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, seed=None,
+                 cuda=None,
+                 quantile=0.1, batch_size=16, n_epochs=200, load_all_data_GPU=False, margin=1., lr=None, optimizer=None,
+                 scheduler=None, start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
         Parameters
         ----------
@@ -488,17 +605,43 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
             The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot
             step. The default value is 1000.
             This is ignored if `simulations` and `parameters` are provided.
+        n_samples_val: int, optional
+            The number of (parameter, simulated data) tuple to be generated to be used as a validation set in the pilot
+            step. The default value is 0, which means no validation set is used.
+            This is ignored if `simulations_val` and `parameters_val` are provided.
         n_samples_per_param: int, optional
             Number of data points in each simulated data set. This is ignored if `simulations` and `parameters` are
             provided. Default to 1.
         parameters: array, optional
             A numpy array with shape (n_samples, n_parameters) that is used, together with `simulations` to fit the
             summary selection learning algorithm. It has to be provided together with `simulations`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
         simulations: array, optional
             A numpy array with shape (n_samples, output_size) that is used, together with `parameters` to fit the
             summary selection learning algorithm. It has to be provided together with `parameters`, in which case no
-            other simulations are performed. Default value is None.
+            other simulations are performed to generate the training data. Default value is None.
+        parameters_val: array, optional
+            A numpy array with shape (n_samples_val, n_parameters) that is used, together with `simulations_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `simulations_val`, in which case no other simulations are performed to generate the validation set. Default 
+            value is None.
+        simulations_val: array, optional
+            A numpy array with shape (n_samples_val, output_size) that is used, together with `parameters_val` as a 
+            validation set in the summary selection learning algorithm. It has to be provided together with 
+            `parameters_val`, in which case no other simulations are performed to generate the validation set. Default
+            value is None.
+        early_stopping: boolean, optional
+            If True, the validation set (which needs to be either provided through the arguments `parameters_val` and
+            `simulations_val` or generated by setting `n_samples_val` to a value larger than 0) is used to early stop
+            the training of the neural network as soon as the loss on the validation set starts to increase. Default
+            value is False.
+        epochs_early_stopping_interval: integer, optional
+            The frequency at which the validation error is compared in order to decide whether to early stop the
+            training or not. Namely, if `epochs_early_stopping_interval=10`, early stopping can happen only at epochs
+            multiple of 10. Defaul value is 1.
+        start_epoch_early_stopping: integer, optional
+            The epoch after which early stopping can happen; in fact, as soon as training starts, there may be a 
+            transient period in which the loss increases. Default value is 10.
         seed: integer, optional
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
@@ -525,10 +668,10 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
         scheduler: torch _LRScheduler class, optional
             A torch _LRScheduler class, used to modify the learning rate across epochs. By default, no scheduler is
             used. Additional parameters may be passed through the `scheduler_kwargs` parameter.
-        start_epoch: integer, optional
-            If a scheduler is provided, for the first `start_epoch` epochs the scheduler is applied to modify the
-            learning rate without training the network. From then on, the training proceeds normally, applying both the
-            scheduler and the optimizer at each epoch. Default to 0.
+        start_epoch_training: integer, optional
+            If a scheduler is provided, for the first `start_epoch_training` epochs the scheduler is applied to modify
+            the learning rate without training the network. From then on, the training proceeds normally, applying both
+            the scheduler and the optimizer at each epoch. Default to 0.
         verbose: boolean, optional
             if True, prints more information from the training routine. Default to False.
         optimizer_kwargs: Python dictionary, optional
@@ -542,12 +685,17 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
 
         super(TripletDistanceLearning, self).__init__(model, statistics_calc, backend, triplet_training,
                                                       distance_learning=True, embedding_net=embedding_net,
-                                                      n_samples=n_samples, n_samples_per_param=n_samples_per_param,
-                                                      parameters=parameters, simulations=simulations, seed=seed,
-                                                      cuda=cuda, quantile=quantile, batch_size=batch_size,
+                                                      n_samples=n_samples, n_samples_val=n_samples_val,
+                                                      n_samples_per_param=n_samples_per_param,
+                                                      parameters=parameters, simulations=simulations,
+                                                      parameters_val=parameters_val, simulations_val=simulations_val,
+                                                      early_stopping=early_stopping,
+                                                      epochs_early_stopping_interval=epochs_early_stopping_interval,
+                                                      start_epoch_early_stopping=start_epoch_early_stopping,
+                                                      seed=seed, cuda=cuda, quantile=quantile, batch_size=batch_size,
                                                       n_epochs=n_epochs, load_all_data_GPU=load_all_data_GPU,
                                                       margin=margin, lr=lr, optimizer=optimizer, scheduler=scheduler,
-                                                      start_epoch=start_epoch, verbose=verbose,
+                                                      start_epoch_training=start_epoch_training,
                                                       optimizer_kwargs=optimizer_kwargs,
                                                       scheduler_kwargs=scheduler_kwargs, loader_kwargs=loader_kwargs)
 
@@ -566,10 +714,12 @@ class ContrastiveDistanceLearning(StatisticsLearningNN):
      Bayesian Computation To Model a Volcanic Eruption. arXiv preprint arXiv:1909.13118.
     """
 
-    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_per_param=1,
-                 parameters=None, simulations=None, seed=None, cuda=None, quantile=0.1, batch_size=16, n_epochs=200,
-                 positive_weight=None, load_all_data_GPU=False, margin=1., lr=None, optimizer=None, scheduler=None,
-                 start_epoch=0, verbose=False, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
+    def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
+                 n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
+                 early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, seed=None,
+                 cuda=None, quantile=0.1, batch_size=16, n_epochs=200, positive_weight=None, load_all_data_GPU=False,
+                 margin=1., lr=None, optimizer=None, scheduler=None,
+                 start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
         Parameters
         ----------
@@ -631,10 +781,10 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
         scheduler: torch _LRScheduler class, optional
             A torch _LRScheduler class, used to modify the learning rate across epochs. By default, no scheduler is
             used. Additional parameters may be passed through the `scheduler_kwargs` parameter.
-        start_epoch: integer, optional
-            If a scheduler is provided, for the first `start_epoch` epochs the scheduler is applied to modify the
-            learning rate without training the network. From then on, the training proceeds normally, applying both the
-            scheduler and the optimizer at each epoch. Default to 0.
+        start_epoch_training: integer, optional
+            If a scheduler is provided, for the first `start_epoch_training` epochs the scheduler is applied to modify
+            the learning rate without training the network. From then on, the training proceeds normally, applying both
+            the scheduler and the optimizer at each epoch. Default to 0.
         verbose: boolean, optional
             if True, prints more information from the training routine. Default to False.
         optimizer_kwargs: Python dictionary, optional
@@ -648,13 +798,20 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
 
         super(ContrastiveDistanceLearning, self).__init__(model, statistics_calc, backend, contrastive_training,
                                                           distance_learning=True, embedding_net=embedding_net,
-                                                          n_samples=n_samples, n_samples_per_param=n_samples_per_param,
-                                                          parameters=parameters, simulations=simulations, seed=seed,
-                                                          cuda=cuda, quantile=quantile, batch_size=batch_size,
-                                                          n_epochs=n_epochs, positive_weight=positive_weight,
+                                                          n_samples=n_samples, n_samples_val=n_samples_val,
+                                                          n_samples_per_param=n_samples_per_param,
+                                                          parameters=parameters, simulations=simulations,
+                                                          parameters_val=parameters_val,
+                                                          simulations_val=simulations_val,
+                                                          early_stopping=early_stopping,
+                                                          epochs_early_stopping_interval=epochs_early_stopping_interval,
+                                                          start_epoch_early_stopping=start_epoch_early_stopping,
+                                                          seed=seed, cuda=cuda, quantile=quantile,
+                                                          batch_size=batch_size, n_epochs=n_epochs,
+                                                          positive_weight=positive_weight,
                                                           load_all_data_GPU=load_all_data_GPU, margin=margin, lr=lr,
                                                           optimizer=optimizer, scheduler=scheduler,
-                                                          start_epoch=start_epoch, verbose=verbose,
+                                                          start_epoch_training=start_epoch_training,
                                                           optimizer_kwargs=optimizer_kwargs,
                                                           scheduler_kwargs=scheduler_kwargs,
                                                           loader_kwargs=loader_kwargs)

From d9855185c9edae981b440c162fe0d628889b6002 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 22 Mar 2020 16:27:50 +0100
Subject: [PATCH 005/106] Update docs

---
 doc/source/getting_started.rst                         | 10 ++++++++--
 .../pmcabc_gaussian_statistics_learning.py             |  8 +++++---
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst
index 025fecd3..f397b5a4 100644
--- a/doc/source/getting_started.rst
+++ b/doc/source/getting_started.rst
@@ -336,7 +336,7 @@ The source code can be found in `examples/approx_lhd/pmc_hierarchical_models.py`
 Statistics Learning
 ~~~~~~~~~~~~~~~~~~~
 
-We have noticed in the `Parameters as Random Variables`_ Section, the discrepancy measure between two datasets is
+As we have discussed in the `Parameters as Random Variables`_ Section, the discrepancy measure between two datasets is
 defined by a distance function between extracted summary statistics from the datasets. Hence, the ABC algorithms are
 subjective to the summary statistics choice. This subjectivity can be avoided by a data-driven summary statistics choice
 from the available summary statistics of the dataset. In ABCpy we provide several statistics learning procedures,
@@ -360,6 +360,12 @@ called, ABCpy checks if Pytorch is present and, if not, asks the user to install
 provide a specific form of neural network, the implementation of the neural network based ones do not require any
 explicit neural network coding, handling all the necessary definitions and training internally.
 
+It is also possible to provide a validation set to the neural network based training routines in order to monitor the
+loss on fresh samples. This can be done for instance by set the parameter `n_samples_val` to a value larger than 0.
+Moreover, it is possible to use the validation set for early stopping, ie stopping the training as soon as the loss on
+the validation set starts increasing. You can do this by setting `early_stopping=True`. Please refer to the API documentation
+(for instance :py:class:`abcpy.statisticslearning.SemiautomaticNN`) for further details.
+
 We note finally that the statistics learning techniques can be applied after compute a first set of statistics; therefore,
 the learned transformation will be a transformation applied to the original set of statistics.
 For instance, consider our initial example from `Parameters as Random Variables`_ where we model the height of humans.
@@ -382,7 +388,7 @@ We remark that the minimal amount of coding needed for using the neural network
 
 .. literalinclude:: ../../examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
     :language: python
-    :lines: 34-40
+    :lines: 34-42
     :dedent: 4
 
 And similarly for the other two approaches.
diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
index 78757acf..cd77da3b 100644
--- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
+++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
@@ -25,16 +25,18 @@ def infer_parameters():
     # Learn the optimal summary statistics using Semiautomatic summary selection
     from abcpy.statisticslearning import Semiautomatic
     statistics_learning = Semiautomatic([height], statistics_calculator, backend,
-                                      n_samples=1000,n_samples_per_param=1, seed=1)
+                                        n_samples=1000, n_samples_per_param=1, seed=1)
 
     # Redefine the statistics function
     new_statistics_calculator = statistics_learning.get_statistics()
 
 
-    # Learn the optimal summary statistics using SemiautomaticNN summary selection
+    # Learn the optimal summary statistics using SemiautomaticNN summary selection;
+    # we use 200 samples as a validation set for early stopping:
     from abcpy.statisticslearning import SemiautomaticNN
     statistics_learning = SemiautomaticNN([height], statistics_calculator, backend,
-                                        n_samples=1000,n_samples_per_param=1, seed=1)
+                                          n_samples=1000, n_samples_val=200,
+                                          n_samples_per_param=1, seed=1, early_stopping=True)
 
     # Redefine the statistics function
     new_statistics_calculator = statistics_learning.get_statistics()

From 88e6789a0dd0de162f7460d7ffc6274e759f7ca4 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 22 Mar 2020 18:30:11 +0100
Subject: [PATCH 006/106] Add use of a scaler before neural network statistics

---
 abcpy/NN_utilities/networks.py | 14 ++++++
 abcpy/statistics.py            | 50 +++++++++++++++++---
 abcpy/statisticslearning.py    | 86 ++++++++++++++++++++++++++++++----
 3 files changed, 134 insertions(+), 16 deletions(-)

diff --git a/abcpy/NN_utilities/networks.py b/abcpy/NN_utilities/networks.py
index e58d8b68..bd411dd8 100644
--- a/abcpy/NN_utilities/networks.py
+++ b/abcpy/NN_utilities/networks.py
@@ -1,3 +1,4 @@
+import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
@@ -97,3 +98,16 @@ def forward(self, x):
 
     return DefaultNN
 
+
+class ScalerAndNet(nn.Module):
+    """Defines a nn.Module class that wraps a scaler and a neural network, and applies the scaler before passing the
+    data through the neural network."""
+
+    def __init__(self, net, scaler):
+        super().__init__()
+        self.net = net
+        self.scaler = scaler
+
+    def forward(self, x):
+        x = torch.tensor(self.scaler.transform(x), dtype=torch.float32).to(next(self.net.parameters()).device)
+        return self.net(x)
diff --git a/abcpy/statistics.py b/abcpy/statistics.py
index 74ea8ce8..1b190338 100644
--- a/abcpy/statistics.py
+++ b/abcpy/statistics.py
@@ -1,4 +1,6 @@
 from abc import ABCMeta, abstractmethod
+
+import cloudpickle
 import numpy as np
 
 try:
@@ -7,8 +9,8 @@
     has_torch = False
 else:
     has_torch = True
-    from abcpy.NN_utilities.utilities import load_net
-    from abcpy.NN_utilities.networks import createDefaultNN
+    from abcpy.NN_utilities.utilities import load_net, save_net
+    from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet
 
 
 class Statistics(metaclass=ABCMeta):
@@ -264,8 +266,8 @@ def __init__(self, net, previous_statistics=None):  # are these default values O
         self.previous_statistics = previous_statistics
 
     @classmethod
-    def fromFile(cls, path_to_net_state_dict, network_class=None, input_size=None, output_size=None, hidden_sizes=None,
-                 previous_statistics=None):
+    def fromFile(cls, path_to_net_state_dict, network_class=None, path_to_scaler=None, input_size=None,
+                 output_size=None, hidden_sizes=None, previous_statistics=None):
         """If the neural network state_dict was saved to the disk, this method can be used to instantiate a
         NeuralEmbedding object with that neural network.
 
@@ -280,6 +282,10 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, input_size=None, o
         In both cases, note that the input size of the neural network must coincide with the size of each of the
         datapoints generated from the model (unless some other statistics are computed beforehand).
 
+        Note that if the neural network was of the class `ScalerAndNet`, ie a scaler was applied before the data is fed
+        through it, you need to pass `path_to_scaler` as well. Then this method will instantiate the network in the
+        correct way.
+
         Parameters
         ----------
         path_to_net_state_dict : basestring
@@ -287,6 +293,10 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, input_size=None, o
         network_class : torch.nn class, optional
             if the neural network class is known explicitly (for instance if the used defined it), then it has to be
              passed here. This must not be provided together with `input_size` or `output_size`.
+        path_to_scaler: basestring, optional
+            The path where the scaler which was applied before the neural network is saved. Note that if the neural
+            network was trained on scaled data and now you do not pass the correct scaler, the behavior will not be
+            correct, leading to wrong inference. Default to None.
         input_size : integer, optional
             if the neural network is an instance of abcpy.NN_utilities.networks.DefaultNN with some input and
             output size, then you should provide here the input size of the network. It has to be provided together with
@@ -327,14 +337,42 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, input_size=None, o
 
         if network_class is not None:  # user explicitly passed the NN class
             net = load_net(path_to_net_state_dict, network_class)
-            statistic_object = cls(net, previous_statistics=previous_statistics)
         else:  # the user passed the input_size, output_size and (maybe) the hidden_sizes
             net = load_net(path_to_net_state_dict, createDefaultNN(input_size=input_size, output_size=output_size,
                                                                    hidden_sizes=hidden_sizes))
-            statistic_object = cls(net, previous_statistics=previous_statistics)
+
+        if path_to_scaler is not None:
+            scaler = cloudpickle.load(open(path_to_scaler, 'rb'))
+            net = ScalerAndNet(net, scaler)
+
+        statistic_object = cls(net, previous_statistics=previous_statistics)
 
         return statistic_object
 
+    def save_net(self, path_to_net_state_dict, path_to_scaler=None):
+        """Method to save the neural network state dict to a file. If the network is of the class ScalerAndNet, ie a
+        scaler is applied before the data is fed through the network, then you are required to pass the path where you
+        want the scaler to be saved.
+        Parameters
+        ----------
+        path_to_net_state_dict: basestring
+            Path where the state dict of the neural network is saved.
+        path_to_scaler: basestring
+            Path where the scaler is saved (with pickle); this is required if the neural network is of the class
+            ScalerAndNet, and is ignored otherwise.
+        """
+        # if the net is of the class ScalerAndNet
+        if hasattr(self.net, "scaler") and path_to_scaler is None:
+            raise RuntimeError("You did not specify path_to_scaler, which is required as the neural network is an "
+                               "element of the class `ScalerAndNet`, ie a scaler is applied before the data is fed"
+                               " through the network")
+
+        if hasattr(self.net, "scaler"):
+            save_net(path_to_net_state_dict, self.net.net)
+            cloudpickle.dump(self.net.scaler, open(path_to_scaler, 'wb'))
+        else:
+            save_net(path_to_net_state_dict, self.net)
+
     def statistics(self, data):
         """
         Parameters
diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 6a287b4a..61d2a767 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -3,7 +3,9 @@
 
 import numpy as np
 from sklearn import linear_model
+from sklearn.preprocessing import MinMaxScaler
 
+from abcpy.NN_utilities.networks import ScalerAndNet
 from abcpy.acceptedparametersmanager import *
 from abcpy.graphtools import GraphTools
 # import dataset and networks definition:
@@ -285,7 +287,7 @@ class StatisticsLearningNN(StatisticsLearning, GraphTools):
 
     def __init__(self, model, statistics_calc, backend, training_routine, distance_learning, embedding_net=None,
                  n_samples=1000, n_samples_val=0, n_samples_per_param=1, parameters=None, simulations=None,
-                 parameters_val=None, simulations_val=None, seed=None, cuda=None, quantile=0.1,
+                 parameters_val=None, simulations_val=None, seed=None, cuda=None, scale_samples=True, quantile=0.1,
                  **training_routine_kwargs):
         """
         Parameters
@@ -342,12 +344,24 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
              If cuda=None, it will select GPU if it is available. Or you can specify True to use GPU or False to use CPU
+        scale_samples: boolean, optional
+            If True, a scaler of the class `sklearn.preprocessing.MinMaxScaler` will be fit on the training data before 
+            neural network training, and training and validation data simulations data will be rescaled. 
+            When calling the `get_statistics` method, 
+            a network of the class `ScalerAndNet` will be used in instantiating the statistics; this network is a 
+            wrapper of a neural network and a scaler and transforms the data with the scaler before applying the neural
+            network.  
+            It is highly recommended to use a scaler, as neural networks are sensitive to the range of input data. A 
+            case in which you may not want to use a scaler is timeseries data, as the scaler works independently on each
+            feature of the data.
+            Default value is True. 
         quantile: float, optional
             quantile used to define the similarity set if distance_learning is True. Default to 0.1.
         training_routine_kwargs:
             additional kwargs to be passed to the underlying training routine.
         """
         self.logger = logging.getLogger(__name__)
+        self.scale_samples = scale_samples
 
         # Define device
         if not has_torch:
@@ -400,6 +414,13 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
                 similarity_set_val = None
             self.logger.debug("Done")
 
+        # set up the scaler and transform the data:
+        if self.scale_samples:
+            self.scaler = MinMaxScaler().fit(simulations)
+            simulations = self.scaler.transform(simulations)
+            if has_val_set:
+                simulations_val = self.scaler.transform(simulations_val)
+
         # now setup the default neural network or not
 
         if isinstance(embedding_net, torch.nn.Module):
@@ -429,16 +450,26 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l
 
         self.logger.info("Finished learning the transformation.")
 
+        self.embedding_net.cpu()  # move back the net to CPU.
+
     def get_statistics(self):
         """
         Returns a NeuralEmbedding Statistics implementing the learned transformation.
 
+        If a scaler was used, the `net` attribute of the returned object is of the class `ScalerAndNet`, which is a
+        nn.Module object wrapping the scaler and the learned neural network and applies the scaler before the data is
+        fed through the neural network.
+
         Returns
         -------
         abcpy.statistics.NeuralEmbedding object
             a statistics object that implements the learned transformation.
         """
-        return NeuralEmbedding(net=self.embedding_net, previous_statistics=self.statistics_calc)
+        if self.scale_samples:
+            return NeuralEmbedding(net=ScalerAndNet(self.embedding_net, self.scaler),
+                                   previous_statistics=self.statistics_calc)
+        else:
+            return NeuralEmbedding(net=self.embedding_net, previous_statistics=self.statistics_calc)
 
 
 # the following classes subclass the base class StatisticsLearningNN with different training routines
@@ -456,7 +487,8 @@ class SemiautomaticNN(StatisticsLearningNN):
     def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
                  n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
                  early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10,
-                 seed=None, cuda=None, batch_size=16, n_epochs=200, load_all_data_GPU=False, lr=1e-3, optimizer=None,
+                 seed=None, cuda=None, scale_samples=True, batch_size=16, n_epochs=200, load_all_data_GPU=False,
+                 lr=1e-3, optimizer=None,
                  scheduler=None, start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
         Parameters
@@ -519,6 +551,17 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
              If cuda=None, it will select GPU if it is available. Or you can specify True to use GPU or False to use CPU
+        scale_samples: boolean, optional
+            If True, a scaler of the class `sklearn.preprocessing.MinMaxScaler` will be fit on the training data before 
+            neural network training, and training and validation data simulations data will be rescaled. 
+            When calling the `get_statistics` method, 
+            a network of the class `ScalerAndNet` will be used in instantiating the statistics; this network is a 
+            wrapper of a neural network and a scaler and transforms the data with the scaler before applying the neural
+            network.  
+            It is highly recommended to use a scaler, as neural networks are sensitive to the range of input data. A 
+            case in which you may not want to use a scaler is timeseries data, as the scaler works independently on each
+            feature of the data.
+            Default value is True. 
         batch_size: integer, optional
             the batch size used for training the neural network. Default is 16
         n_epochs: integer, optional
@@ -558,7 +601,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
                                               early_stopping=early_stopping,
                                               epochs_early_stopping_interval=epochs_early_stopping_interval,
                                               start_epoch_early_stopping=start_epoch_early_stopping,
-                                              seed=seed, cuda=cuda, batch_size=batch_size,
+                                              seed=seed, cuda=cuda, scale_samples=scale_samples, batch_size=batch_size,
                                               n_epochs=n_epochs, load_all_data_GPU=load_all_data_GPU, lr=lr,
                                               optimizer=optimizer, scheduler=scheduler,
                                               start_epoch_training=start_epoch_training,
@@ -582,7 +625,7 @@ class TripletDistanceLearning(StatisticsLearningNN):
     def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
                  n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
                  early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, seed=None,
-                 cuda=None,
+                 cuda=None, scale_samples=True,
                  quantile=0.1, batch_size=16, n_epochs=200, load_all_data_GPU=False, margin=1., lr=None, optimizer=None,
                  scheduler=None, start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
@@ -646,6 +689,17 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
              If cuda=None, it will select GPU if it is available. Or you can specify True to use GPU or False to use CPU
+        scale_samples: boolean, optional
+            If True, a scaler of the class `sklearn.preprocessing.MinMaxScaler` will be fit on the training data before 
+            neural network training, and training and validation data simulations data will be rescaled. 
+            When calling the `get_statistics` method, 
+            a network of the class `ScalerAndNet` will be used in instantiating the statistics; this network is a 
+            wrapper of a neural network and a scaler and transforms the data with the scaler before applying the neural
+            network.  
+            It is highly recommended to use a scaler, as neural networks are sensitive to the range of input data. A 
+            case in which you may not want to use a scaler is timeseries data, as the scaler works independently on each
+            feature of the data.
+            Default value is True. 
         quantile: float, optional
             quantile used to define the similarity set if distance_learning is True. Default to 0.1.
         batch_size: integer, optional
@@ -692,7 +746,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
                                                       early_stopping=early_stopping,
                                                       epochs_early_stopping_interval=epochs_early_stopping_interval,
                                                       start_epoch_early_stopping=start_epoch_early_stopping,
-                                                      seed=seed, cuda=cuda, quantile=quantile, batch_size=batch_size,
+                                                      seed=seed, cuda=cuda, scale_samples=scale_samples,
+                                                      quantile=quantile, batch_size=batch_size,
                                                       n_epochs=n_epochs, load_all_data_GPU=load_all_data_GPU,
                                                       margin=margin, lr=lr, optimizer=optimizer, scheduler=scheduler,
                                                       start_epoch_training=start_epoch_training,
@@ -717,8 +772,8 @@ class ContrastiveDistanceLearning(StatisticsLearningNN):
     def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0,
                  n_samples_per_param=1, parameters=None, simulations=None, parameters_val=None, simulations_val=None,
                  early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, seed=None,
-                 cuda=None, quantile=0.1, batch_size=16, n_epochs=200, positive_weight=None, load_all_data_GPU=False,
-                 margin=1., lr=None, optimizer=None, scheduler=None,
+                 cuda=None, scale_samples=True, quantile=0.1, batch_size=16, n_epochs=200, positive_weight=None,
+                 load_all_data_GPU=False, margin=1., lr=None, optimizer=None, scheduler=None,
                  start_epoch_training=0, optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
         """
         Parameters
@@ -755,6 +810,17 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
             Optional initial seed for the random number generator. The default value is generated randomly.
         cuda: boolean, optional
              If cuda=None, it will select GPU if it is available. Or you can specify True to use GPU or False to use CPU
+        scale_samples: boolean, optional
+            If True, a scaler of the class `sklearn.preprocessing.MinMaxScaler` will be fit on the training data before 
+            neural network training, and training and validation data simulations data will be rescaled. 
+            When calling the `get_statistics` method, 
+            a network of the class `ScalerAndNet` will be used in instantiating the statistics; this network is a 
+            wrapper of a neural network and a scaler and transforms the data with the scaler before applying the neural
+            network.  
+            It is highly recommended to use a scaler, as neural networks are sensitive to the range of input data. A 
+            case in which you may not want to use a scaler is timeseries data, as the scaler works independently on each
+            feature of the data.
+            Default value is True. 
         quantile: float, optional
             quantile used to define the similarity set if distance_learning is True. Default to 0.1.
         batch_size: integer, optional
@@ -806,8 +872,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample
                                                           early_stopping=early_stopping,
                                                           epochs_early_stopping_interval=epochs_early_stopping_interval,
                                                           start_epoch_early_stopping=start_epoch_early_stopping,
-                                                          seed=seed, cuda=cuda, quantile=quantile,
-                                                          batch_size=batch_size, n_epochs=n_epochs,
+                                                          seed=seed, cuda=cuda, scale_samples=scale_samples,
+                                                          quantile=quantile, batch_size=batch_size, n_epochs=n_epochs,
                                                           positive_weight=positive_weight,
                                                           load_all_data_GPU=load_all_data_GPU, margin=margin, lr=lr,
                                                           optimizer=optimizer, scheduler=scheduler,

From ae5b1424011357a8df4955a14cf97952fdbe9e8e Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 23 Mar 2020 10:29:10 +0100
Subject: [PATCH 007/106] Fix bug in early stopping

---
 abcpy/NN_utilities/trainer.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/abcpy/NN_utilities/trainer.py b/abcpy/NN_utilities/trainer.py
index 0e6bbfa6..37a83a12 100644
--- a/abcpy/NN_utilities/trainer.py
+++ b/abcpy/NN_utilities/trainer.py
@@ -43,14 +43,17 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_
             # early stopping:
             if early_stopping and (epoch + 1) % epochs_early_stopping_interval == 0:
                 validation_loss_list.append(val_loss)  # save the previous validation loss. It is actually
-                net_state_dict = model.state_dict()
-                # we need to have at least two saved test losses for performing early stopping.
+                # we need to have at least two saved test losses for performing early stopping (in which case we know
+                # we have saved the previous state_dict as well).
                 if epoch + 1 >= start_epoch_early_stopping and len(validation_loss_list) > 1:
                     if validation_loss_list[-1] > validation_loss_list[-2]:
                         logger.info("Training has been early stopped at epoch {}.".format(epoch + 1))
                         # reload the previous state dict:
                         model.load_state_dict(net_state_dict)
                         break  # stop training
+                # if we did not stop: update the state dict to the next value
+                net_state_dict = model.state_dict()
+
         scheduler.step()
 
 

From 6cf3ff8afc2896ed6f616c7e05377773f451ab7a Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 23 Mar 2020 17:30:57 +0100
Subject: [PATCH 008/106] Fix docs

---
 abcpy/NN_utilities/datasets.py |  4 ++--
 abcpy/NN_utilities/trainer.py  |  3 ---
 abcpy/graphtools.py            |  6 +++---
 abcpy/output.py                | 24 +++++++++++++++---------
 abcpy/perturbationkernel.py    |  4 ++--
 abcpy/probabilisticmodels.py   |  2 +-
 doc/source/postanalysis.rst    | 10 ++++++++++
 7 files changed, 33 insertions(+), 20 deletions(-)

diff --git a/abcpy/NN_utilities/datasets.py b/abcpy/NN_utilities/datasets.py
index d0a9bfd3..d0cf01ab 100644
--- a/abcpy/NN_utilities/datasets.py
+++ b/abcpy/NN_utilities/datasets.py
@@ -37,7 +37,7 @@ def __len__(self):
 
 class SiameseSimilarities(Dataset):
     """
-    This class defines a dataset returning pairs of similar and dissimilar examples. It has to be instantiated with a
+    This class defines a dataset returning pairs of similar and dissimilar samples. It has to be instantiated with a
     dataset of the class Similarities
     """
 
@@ -88,7 +88,7 @@ def __len__(self):
 
 class TripletSimilarities(Dataset):
     """
-    This class defines a dataset returning triplets of anchor, positive and negative examples. 
+    This class defines a dataset returning triplets of anchor, positive and negative samples.
     It has to be instantiated with a dataset of the class Similarities.
     """
 
diff --git a/abcpy/NN_utilities/trainer.py b/abcpy/NN_utilities/trainer.py
index 37a83a12..9accc9c9 100644
--- a/abcpy/NN_utilities/trainer.py
+++ b/abcpy/NN_utilities/trainer.py
@@ -12,9 +12,6 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_
     i.e. The model should be able to process data output of loaders,
     loss function should process target output of loaders and outputs from the model
 
-    Examples: Classification: batch loader, classification model, NLL loss, accuracy metric
-    Siamese network: Siamese loader, siamese model, contrastive loss
-
     Adapted from https://github.com/adambielski/siamese-triplet
     """
 
diff --git a/abcpy/graphtools.py b/abcpy/graphtools.py
index 9a276434..05b2f913 100644
--- a/abcpy/graphtools.py
+++ b/abcpy/graphtools.py
@@ -96,7 +96,7 @@ def pdf_of_prior(self, models, parameters, mapping=None, is_root=True):
             Defines the models for which the pdf of their prior should be evaluated
         parameters: python list
             The parameters at which the pdf should be evaluated
-        mapping: list of tupels
+        mapping: list of tuples
             Defines the mapping of probabilistic models and index in a parameter list.
         is_root: boolean
             A flag specifying whether the provided models are the root models. This is to ensure that the pdf is calculated correctly.
@@ -121,7 +121,7 @@ def _recursion_pdf_of_prior(self, models, parameters, mapping=None, is_root=True
             Defines the models for which the pdf of their prior should be evaluated
         parameters: python list
             The parameters at which the pdf should be evaluated
-        mapping: list of tupels
+        mapping: list of tuples
             Defines the mapping of probabilistic models and index in a parameter list.
         is_root: boolean
             A flag specifying whether the provided models are the root models. This is to ensure that the pdf is calculated correctly.
@@ -234,7 +234,7 @@ def _get_names_and_parameters(self):
         Returns
         -------
         list:
-            Each entry is a tupel, the first entry of which is the name of the model and the second entry is the parameter values associated with it
+            Each entry is a tuple, the first entry of which is the name of the model and the second entry is the parameter values associated with it
         """
         mapping = self._get_mapping()[0]
 
diff --git a/abcpy/output.py b/abcpy/output.py
index 9a77ee67..6446a288 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -80,12 +80,14 @@ def fromFile(cls, filename):
 
     def add_user_parameters(self, names_and_params):
         """
-        Saves the provided parameters and names of the probabilistic models corresponding to them. If type==0, old parameters get overwritten.
+        Saves the provided parameters and names of the probabilistic models corresponding to them. If type==0, old
+        parameters get overwritten.
 
         Parameters
         ----------
         names_and_params: list
-            Each entry is a tupel, where the first entry is the name of the probabilistic model, and the second entry is the parameters associated with this model.
+            Each entry is a tuple, where the first entry is the name of the probabilistic model, and the second entry is
+            the parameters associated with this model.
         """
         if (self._type == 0):
             self.names_and_parameters = [dict(names_and_params)]
@@ -141,7 +143,8 @@ def add_distances(self, distances):
 
     def add_opt_values(self, opt_values):
         """
-        Saves provided values of the evaluation of the schemes objective function. If type==0, old values get overwritten
+        Saves provided values of the evaluation of the schemes objective function. If type==0, old values get
+        overwritten
 
         Parameters
         ----------
@@ -267,8 +270,8 @@ def posterior_mean(self, iteration=None):
         Returns
         -------
         posterior mean: dictionary
-            Posterior mean from the specified iteration (last, if not specified) returned as a disctionary with names of the
-            random variables
+            Posterior mean from the specified iteration (last, if not specified) returned as a disctionary with names of
+            the random variables
         """
 
         if iteration is None:
@@ -352,13 +355,16 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
         pair of parameters.
 
         This visualization is not satisfactory for parameters that take on discrete values, specially in the case where
-        the number of values it can assume are small.
+        the number of values it can assume are small, as it obtains the posterior by KDE in this case as well. We need
+        to improve on that, considering histograms.
 
         Parameters
         ----------
         parameters_to_show : list, optional
             a list of the parameters for which you want to plot the posterior distribution. For each parameter, you need
-            to provide the name string as it was defined in the model.
+            to provide the name string as it was defined in the model. For instance,
+            `jrnl.plot_posterior_distr(parameters_to_show=["mu"])` will only plot the posterior distribution for the
+            parameter named "mu" in the list of parameters.
             If `None`, then all parameters will be displayed.
         ranges_parameters : Python dictionary, optional
             a dictionary in which you can optionally provide the plotting range for the parameters that you chose to
@@ -373,8 +379,8 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
             specifies if you want to show the posterior samples overimposed to the contourplots of the posterior
             distribution. If `None`, the default behaviour is the following: if the posterior samples are associated
             with importance weights, then the samples are not showed (in fact, the KDE for the posterior distribution
-            takes into account the weights, and showing the samples may be misleading). Otherwise, if the posterior #
-            samples are not associated with weights, they are displayed by defauly.
+            takes into account the weights, and showing the samples may be misleading). Otherwise, if the posterior
+            samples are not associated with weights, they are displayed by default.
         single_marginals_only : boolean, optional
             if `True`, the method does not show the paired marginals but only the single parameter marginals;
             otherwise, it shows the paired marginals as well. Default to `False`.
diff --git a/abcpy/perturbationkernel.py b/abcpy/perturbationkernel.py
index b399450d..39163e75 100644
--- a/abcpy/perturbationkernel.py
+++ b/abcpy/perturbationkernel.py
@@ -184,7 +184,7 @@ def update(self, accepted_parameters_manager, row_index, rng=np.random.RandomSta
         Returns
         -------
         list
-            The list contains tupels. Each tupel contains as the first entry a probabilistic model and as the second
+            The list contains tuples. Each tuple contains as the first entry a probabilistic model and as the second
             entry the perturbed parameter values corresponding to this model.
         """
 
@@ -216,7 +216,7 @@ def pdf(self, mapping, accepted_parameters_manager, mean, x):
         Parameters
         ----------
         mapping: list
-            Each entry is a tupel of which the first entry is a abcpy.ProbabilisticModel object, the second entry is the
+            Each entry is a tuple of which the first entry is a abcpy.ProbabilisticModel object, the second entry is the
             index in the accepted_parameters_bds list corresponding to an output of this model.
         accepted_parameters_manager: abcpy.AcceptedParametersManager object
             The AcceptedParametersManager to be used.
diff --git a/abcpy/probabilisticmodels.py b/abcpy/probabilisticmodels.py
index 7a3d625c..79e7de10 100644
--- a/abcpy/probabilisticmodels.py
+++ b/abcpy/probabilisticmodels.py
@@ -292,7 +292,7 @@ def __init__(self, input_connector, name=''):
 
     def __getitem__(self, item):
         """
-        Overloads the access operator. If the access operator is called, a tupel of the ProbablisticModel that called
+        Overloads the access operator. If the access operator is called, a tuple of the ProbablisticModel that called
         the operator and the index at which it was called is returned. Commonly used at initialization of new
         probabilistic models to specify a mapping between model outputs and parameters.
 
diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst
index 2462be32..2b48e283 100644
--- a/doc/source/postanalysis.rst
+++ b/doc/source/postanalysis.rst
@@ -63,6 +63,16 @@ Finally, you can plot the inferred posterior mean of the parameters in the follo
     :lines: 65
     :dedent: 4
 
+The above line plots the posterior distribution for all the parameters; if you instead want to plot it for some
+parameters only, you can use the `parameters_to_show` argument; in addition, the `ranges_parameters` argument can be
+used to provide a dictionary specifying the limits for the axis in the plots:
+
+.. code-block:: python
+
+    journal.plot_posterior_distr(parameters_to_show='parameter_1',
+                                 ranges_parameters={'parameter_1': [0,2]})
+
+
 And certainly, a journal can easily be saved to and loaded from disk:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py

From d69ec234162fa06c91debe6e014111c9f39a9383 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 5 Apr 2020 10:56:23 +0200
Subject: [PATCH 009/106] Fix issue with dataSame in distances computation

---
 abcpy/distances.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/abcpy/distances.py b/abcpy/distances.py
index fa413f26..e04875a8 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -136,7 +136,7 @@ def distance(self, d1, d2):
         # Check whether d1 is same as self.data_set
         if self.data_set is not None:
             if len(np.array(d1[0]).reshape(-1,)) == 1:
-                self.data_set == d1
+                self.dataSame = self.data_set == d1
             else:
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 

From 8663c37295721628db6d3b7f50d0307f30576f37 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 5 Apr 2020 12:09:32 +0200
Subject: [PATCH 010/106] Fix tests for neural network learning routines with
 scalers

---
 abcpy/statisticslearning.py       |  1 -
 tests/statisticslearning_tests.py | 36 +++++++++++++++++++++++++++++--
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 61d2a767..3311b7a5 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -277,7 +277,6 @@ def get_statistics(self):
         return LinearTransformation(np.transpose(self.coefficients_learnt), previous_statistics=self.statistics_calc)
 
 
-# TODO add scaler before applying the neural network ?
 class StatisticsLearningNN(StatisticsLearning, GraphTools):
     """This is the base class for all the statistics learning techniques involving neural networks. In most cases, you
     should not instantiate this directly. The actual classes instantiate this with the right arguments.
diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py
index 285147f2..39078a4c 100644
--- a/tests/statisticslearning_tests.py
+++ b/tests/statisticslearning_tests.py
@@ -63,7 +63,11 @@ def setUp(self):
         if has_torch:
             # Initialize statistics learning
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100,
-                                                      n_samples_per_param=1, seed=1, n_epochs=10)
+                                                      n_samples_per_param=1, seed=1, n_epochs=10, scale_samples=False)
+            # with sample scaler:
+            self.statisticslearning_with_scaler = SemiautomaticNN([self.Y], self.statistics_cal, self.backend,
+                                                                  n_samples=100, n_samples_per_param=1, seed=1,
+                                                                  n_epochs=10, scale_samples=True)
 
     def test_initialization(self):
         if not has_torch:
@@ -73,6 +77,7 @@ def test_transformation(self):
         if has_torch:
             # Transform statistics extraction
             self.new_statistics_calculator = self.statisticslearning.get_statistics()
+            self.new_statistics_calculator_with_scaler = self.statisticslearning_with_scaler.get_statistics()
             # Simulate observed data
             Obs = Normal([2, 4])
             y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist()
@@ -82,6 +87,11 @@ def test_transformation(self):
 
             self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])])
 
+            extracted_statistics = self.new_statistics_calculator_with_scaler.statistics(y_obs)
+            self.assertEqual(np.shape(extracted_statistics), (1, 2))
+
+            self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])])
+
 
 class ContrastiveDistanceLearningTests(unittest.TestCase):
     def setUp(self):
@@ -100,7 +110,12 @@ def setUp(self):
             # Initialize statistics learning
             self.statisticslearning = ContrastiveDistanceLearning([self.Y], self.statistics_cal, self.backend,
                                                                   n_samples=100, n_samples_per_param=1, seed=1,
-                                                                  n_epochs=10)
+                                                                  n_epochs=10, scale_samples=False)
+            # with sample scaler:
+            self.statisticslearning_with_scaler = ContrastiveDistanceLearning([self.Y], self.statistics_cal,
+                                                                              self.backend, n_samples=100,
+                                                                              n_samples_per_param=1, seed=1,
+                                                                              n_epochs=10, scale_samples=True)
 
     def test_initialization(self):
         if not has_torch:
@@ -111,6 +126,7 @@ def test_transformation(self):
         if has_torch:
             # Transform statistics extraction
             self.new_statistics_calculator = self.statisticslearning.get_statistics()
+            self.new_statistics_calculator_with_scaler = self.statisticslearning_with_scaler.get_statistics()
             # Simulate observed data
             Obs = Normal([2, 4])
             y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist()
@@ -120,6 +136,11 @@ def test_transformation(self):
 
             self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])])
 
+            extracted_statistics = self.new_statistics_calculator_with_scaler.statistics(y_obs)
+            self.assertEqual(np.shape(extracted_statistics), (1, 2))
+
+            self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])])
+
 
 class TripletDistanceLearningTests(unittest.TestCase):
     def setUp(self):
@@ -137,6 +158,11 @@ def setUp(self):
         if has_torch:
             # Initialize statistics learning
             self.statisticslearning = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend,
+                                                              scale_samples=False,
+                                                              n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10)
+            # with sample scaler:
+            self.statisticslearning_with_scaler = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend,
+                                                              scale_samples=True,
                                                               n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10)
 
     def test_initialization(self):
@@ -147,6 +173,7 @@ def test_transformation(self):
         if has_torch:
             # Transform statistics extraction
             self.new_statistics_calculator = self.statisticslearning.get_statistics()
+            self.new_statistics_calculator_with_scaler = self.statisticslearning_with_scaler.get_statistics()
             # Simulate observed data
             Obs = Normal([2, 4])
             y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist()
@@ -156,6 +183,11 @@ def test_transformation(self):
 
             self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])])
 
+            extracted_statistics = self.new_statistics_calculator_with_scaler.statistics(y_obs)
+            self.assertEqual(np.shape(extracted_statistics), (1, 2))
+
+            self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])])
+
 
 if __name__ == '__main__':
     unittest.main()

From c01942a159ce76ff196c0128066cc4068442fb0e Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 18 Apr 2020 17:49:02 +0200
Subject: [PATCH 011/106] Fix small issues in `plot_posterior_distr` method

---
 abcpy/output.py | 38 ++++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/abcpy/output.py b/abcpy/output.py
index 6446a288..c6cad27b 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -342,10 +342,11 @@ def posterior_histogram(self, iteration=None, n_bins=10):
         H, edges = np.histogramdd(np.hstack(joined_params), bins=n_bins, weights=weights.reshape(len(weights), ))
         return [H, edges]
 
+    # TODO this does not work for multidimensional parameters
     def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None, iteration=None, show_samples=None,
                              single_marginals_only=False, double_marginals_only=False, write_posterior_mean=True,
-                             true_parameter_values=None, contour_levels=14, show_density_values=True, bw_method=None,
-                             path_to_save=None):
+                             show_posterior_mean=True, true_parameter_values=None, contour_levels=14,
+                             show_density_values=True, bw_method=None, path_to_save=None):
         """
         Produces a visualization of the posterior distribution of the parameters of the model.
 
@@ -390,6 +391,8 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
             Default to `False`.
         write_posterior_mean : boolean, optional
             Whether to write or not the posterior mean on the single marginal plots. Default to `True`.
+        show_posterior_mean: boolean, optional
+            Whether to display a line corresponding to the posterior mean value in the plot. Default to `True`.
         true_parameter_values: array-like, optional
             you can provide here the true values of the parameters, if known, and that will be displayed in the
             posterior plot. It has to be an array-like of the same length of `parameters_to_show` (if that is provided),
@@ -436,7 +439,7 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
             if len(true_parameter_values) != len(parameters_to_show):
                 raise RuntimeError("You need to provide values for all the parameters to be shown.")
 
-        meanpost = np.array([self.posterior_mean()[x] for x in parameters_to_show])
+        meanpost = np.array([self.posterior_mean(iteration=iteration)[x] for x in parameters_to_show])
 
         post_samples_dict = {name: np.concatenate(self.get_parameters(iteration)[name]) for name in parameters_to_show}
 
@@ -491,8 +494,8 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
                 ranges_parameters[name] = [np.min(post_samples_dict[name]) - 0.05 * difference,
                                            np.max(post_samples_dict[name]) + 0.05 * difference]
 
-        def write_post_mean_function(ax, post_mean, name):
-            ax.text(0.15, 0.06, r"Post. mean = {:.2f}".format(post_mean), size=14.5 * 2 / len(meanpost),
+        def write_post_mean_function(ax, post_mean):
+            ax.text(0.15, 0.06, r"Post. mean = {:.2f}".format(post_mean), size=16,
                     transform=ax.transAxes)
 
         def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwargs):
@@ -552,10 +555,11 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
                             kernel = gaussian_kde(values, weights=weights, bw_method=bw_method)
                             Z = np.reshape(kernel(positions).T, X.shape)
                             # axes[x, y].plot(meanpost[y], meanpost[x], 'r+', markersize='10')
-                            axes[x, y].plot([xmin, xmax], [meanpost[x], meanpost[x]], "red", markersize='20',
-                                            linestyle='solid')
-                            axes[x, y].plot([meanpost[y], meanpost[y]], [ymin, ymax], "red", markersize='20',
-                                            linestyle='solid')
+                            if show_posterior_mean:
+                                axes[x, y].plot([xmin, xmax], [meanpost[x], meanpost[x]], "red", markersize='20',
+                                                linestyle='solid')
+                                axes[x, y].plot([meanpost[y], meanpost[y]], [ymin, ymax], "red", markersize='20',
+                                                linestyle='solid')
                             if true_parameter_values is not None:
                                 axes[x, y].plot([xmin, xmax], [true_parameter_values[x], true_parameter_values[x]],
                                                 "green",
@@ -585,14 +589,15 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
                                       alpha=1, label="Density")
                 values = gaussian_kernel(positions)
                 # axes[i, i].plot([positions[np.argmax(values)], positions[np.argmax(values)]], [0, np.max(values)])
-                diagonal_axes[i].plot([meanpost[i], meanpost[i]], [0, 1.1 * np.max(values)], "red", alpha=1,
-                                      label="Posterior mean")
+                if show_posterior_mean:
+                    diagonal_axes[i].plot([meanpost[i], meanpost[i]], [0, 1.1 * np.max(values)], "red", alpha=1,
+                                          label="Posterior mean")
                 if true_parameter_values is not None:
                     diagonal_axes[i].plot([true_parameter_values[i], true_parameter_values[i]],
                                           [0, 1.1 * np.max(values)], "green",
                                           alpha=1, label="True value")
                 if write_posterior_mean:
-                    write_post_mean_function(diagonal_axes[i], meanpost[i], label)
+                    write_post_mean_function(diagonal_axes[i], meanpost[i])
                 diagonal_axes[i].set_xlim([xmin, xmax])
                 diagonal_axes[i].set_ylim([0, 1.1 * np.max(values)])
 
@@ -655,10 +660,11 @@ def double_marginals_plot(data, meanpost, names, **kwargs):
                     kernel = gaussian_kde(values, weights=weights, bw_method=bw_method)
                     Z = np.reshape(kernel(positions).T, X.shape)
                     # axes[x, y].plot(meanpost[y], meanpost[x], 'r+', markersize='10')
-                    axes[ax_counter].plot([xmin, xmax], [meanpost[x], meanpost[x]], "red", markersize='20',
-                                          linestyle='solid')
-                    axes[ax_counter].plot([meanpost[y], meanpost[y]], [ymin, ymax], "red", markersize='20',
-                                          linestyle='solid')
+                    if show_posterior_mean:
+                        axes[ax_counter].plot([xmin, xmax], [meanpost[x], meanpost[x]], "red", markersize='20',
+                                              linestyle='solid')
+                        axes[ax_counter].plot([meanpost[y], meanpost[y]], [ymin, ymax], "red", markersize='20',
+                                              linestyle='solid')
                     if true_parameter_values is not None:
                         axes[ax_counter].plot([xmin, xmax], [true_parameter_values[x], true_parameter_values[x]],
                                               "green",

From 9251c40f91c8cd3e901b08ee2897b8813365953c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sun, 19 Apr 2020 18:28:12 +0200
Subject: [PATCH 012/106] Fix text and fig size for plot.

---
 abcpy/output.py | 59 +++++++++++++++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 16 deletions(-)

diff --git a/abcpy/output.py b/abcpy/output.py
index c6cad27b..9e4ceeae 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -345,7 +345,7 @@ def posterior_histogram(self, iteration=None, n_bins=10):
     # TODO this does not work for multidimensional parameters
     def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None, iteration=None, show_samples=None,
                              single_marginals_only=False, double_marginals_only=False, write_posterior_mean=True,
-                             show_posterior_mean=True, true_parameter_values=None, contour_levels=14,
+                             show_posterior_mean=True, true_parameter_values=None, contour_levels=14, figsize=None,
                              show_density_values=True, bw_method=None, path_to_save=None):
         """
         Produces a visualization of the posterior distribution of the parameters of the model.
@@ -401,6 +401,9 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
             the same order the model `forward_simulate` step takes.
         contour_levels: integer, optional
             The number of levels to be used in the contour plots. Default to 14.
+        figsize: float, optional
+            Denotes the size (in inches) of the smaller dimension of the plot; the other dimension is automatically
+            determined. If None, then figsize is chosen automatically. Default to `None`.
         show_density_values: boolean, optional
             If `True`, the method displays the value of the density at each contour level in the contour plot. Default
             to `True`.
@@ -494,8 +497,8 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
                 ranges_parameters[name] = [np.min(post_samples_dict[name]) - 0.05 * difference,
                                            np.max(post_samples_dict[name]) + 0.05 * difference]
 
-        def write_post_mean_function(ax, post_mean):
-            ax.text(0.15, 0.06, r"Post. mean = {:.2f}".format(post_mean), size=16,
+        def write_post_mean_function(ax, post_mean, size):
+            ax.text(0.15, 0.06, r"Post. mean = {:.2f}".format(post_mean), size=size,
                     transform=ax.transAxes)
 
         def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwargs):
@@ -506,11 +509,15 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
             passed on to matplotlib's "plot" command. Returns the matplotlib figure
             object containg the subplot grid.
             """
+            if figsize is None:
+                figsize_actual = 4 * len(names)
+            else:
+                figsize_actual = figsize
             numvars, numdata = data.shape
             if single_marginals_only:
-                fig, axes = plt.subplots(nrows=1, ncols=numvars, figsize=(4 * len(names), 4))
+                fig, axes = plt.subplots(nrows=1, ncols=numvars, figsize=(figsize_actual, figsize_actual / len(names)))
             else:
-                fig, axes = plt.subplots(nrows=numvars, ncols=numvars, figsize=(8, 8))
+                fig, axes = plt.subplots(nrows=numvars, ncols=numvars, figsize=(figsize_actual, figsize_actual))
                 fig.subplots_adjust(hspace=0.08, wspace=0.08)
 
             # if we have to plot 1 single parameter value, envelop the ax in an array, so that it gives no troubles:
@@ -570,7 +577,7 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
 
                             CS = axes[x, y].contour(X, Y, Z, contour_levels, linestyles='solid')
                             if show_density_values:
-                                axes[x, y].clabel(CS, fontsize=9, inline=1)
+                                axes[x, y].clabel(CS, fontsize=figsize_actual / len(names) * 2.25, inline=1)
                             axes[x, y].set_xlim([xmin, xmax])
                             axes[x, y].set_ylim([ymin, ymax])
 
@@ -580,6 +587,10 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
                 diagonal_axes = np.array([axes[i, i] for i in range(len(axes))])
             else:
                 diagonal_axes = axes
+            label_size = figsize_actual / len(names) * 4
+            title_size = figsize_actual / len(names) * 4.25
+            post_mean_size = figsize_actual / len(names) * 4
+            ticks_size = figsize_actual / len(names) * 3
 
             for i, label in enumerate(names):
                 xmin, xmax = ranges_parameters[names[i]]
@@ -597,32 +608,38 @@ def scatterplot_matrix(data, meanpost, names, single_marginals_only=False, **kwa
                                           [0, 1.1 * np.max(values)], "green",
                                           alpha=1, label="True value")
                 if write_posterior_mean:
-                    write_post_mean_function(diagonal_axes[i], meanpost[i])
+                    write_post_mean_function(diagonal_axes[i], meanpost[i], size=post_mean_size)
                 diagonal_axes[i].set_xlim([xmin, xmax])
                 diagonal_axes[i].set_ylim([0, 1.1 * np.max(values)])
 
             # labels and ticks:
             if not single_marginals_only:
                 for j, label in enumerate(names):
-                    axes[0, j].set_title(label, size=17)
+                    axes[0, j].set_title(label, size=title_size)
 
                     if len(names) > 1:
-                        axes[j, 0].set_ylabel(label)
-                        axes[-1, j].set_xlabel(label)
+                        axes[j, 0].set_ylabel(label, size=label_size)
+                        axes[-1, j].set_xlabel(label, size=label_size)
                     else:
-                        axes[j, 0].set_ylabel("Density")
+                        axes[j, 0].set_ylabel("Density", size=label_size)
 
+                    axes[j, 0].tick_params(axis='both', which='major', labelsize=ticks_size)
                     axes[j, 0].ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
+                    axes[j, 0].yaxis.offsetText.set_fontsize(ticks_size)
                     axes[j, 0].yaxis.set_visible(True)
 
+                    axes[-1, j].tick_params(axis='both', which='major', labelsize=ticks_size)
                     axes[-1, j].ticklabel_format(style='sci', axis='x')  # , scilimits=(0, 0))
+                    axes[-1, j].xaxis.offsetText.set_fontsize(ticks_size)
                     axes[-1, j].xaxis.set_visible(True)
+                    axes[j, -1].tick_params(axis='both', which='major', labelsize=ticks_size)
+                    axes[j, -1].yaxis.offsetText.set_fontsize(ticks_size)
                     axes[j, -1].ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
                     axes[j, -1].yaxis.set_visible(True)
 
             else:
                 for j, label in enumerate(names):
-                    axes[j].set_title(label, size=17)
+                    axes[j].set_title(label, size=figsize_actual / len(names) * 4.25)
                 axes[0].set_ylabel("Density")
 
             return fig, axes
@@ -635,7 +652,12 @@ def double_marginals_plot(data, meanpost, names, **kwargs):
             """
             numvars, numdata = data.shape
             numplots = np.int(numvars * (numvars - 1) / 2)
-            fig, axes = plt.subplots(nrows=1, ncols=numplots, figsize=(4 * numplots, 4))
+            if figsize is None:
+                figsize_actual = 4 * numplots
+            else:
+                figsize_actual = figsize
+
+            fig, axes = plt.subplots(nrows=1, ncols=numplots, figsize=(figsize_actual, figsize_actual / numplots))
 
             if numplots == 1:  # in this case you will only have one plot. Envelop it to avoid problems.
                 axes = [axes]
@@ -675,16 +697,21 @@ def double_marginals_plot(data, meanpost, names, **kwargs):
 
                     CS = axes[ax_counter].contour(X, Y, Z, contour_levels, linestyles='solid')
                     if show_density_values:
-                        axes[ax_counter].clabel(CS, fontsize=9, inline=1)
+                        axes[ax_counter].clabel(CS, fontsize=figsize_actual / numplots * 2.25, inline=1)
                     axes[ax_counter].set_xlim([xmin, xmax])
                     axes[ax_counter].set_ylim([ymin, ymax])
 
-                    axes[ax_counter].set_ylabel(names[x])
-                    axes[ax_counter].set_xlabel(names[y])
+                    label_size = figsize_actual / numplots * 4
+                    ticks_size = figsize_actual / numplots * 3
+                    axes[ax_counter].set_ylabel(names[x], size=label_size)
+                    axes[ax_counter].set_xlabel(names[y], size=label_size)
 
+                    axes[ax_counter].tick_params(axis='both', which='major', labelsize=ticks_size)
                     axes[ax_counter].ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
+                    axes[ax_counter].yaxis.offsetText.set_fontsize(ticks_size)
                     axes[ax_counter].yaxis.set_visible(True)
                     axes[ax_counter].ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
+                    axes[ax_counter].yaxis.offsetText.set_fontsize(ticks_size)
                     axes[ax_counter].xaxis.set_visible(True)
 
                     ax_counter += 1

From 6ef21501bdb582f6c123784e210f0187d3bcbadf Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 21 Apr 2020 15:32:56 +0200
Subject: [PATCH 013/106] Fix some issues in PMC: did not update covariance
 matrix, and used very slow for loop to update weights.

---
 abcpy/inferences.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 535e84ce..a94a1ed5 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -844,13 +844,13 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             new_weights_pds = self.backend.map(self._calculate_weight, new_parameters_pds)
             new_weights = np.array(self.backend.collect(new_weights_pds)).reshape(-1, 1)
 
-            sum_of_weights = 0.0
-            for i in range(0, self.n_samples):
-                new_weights[i] = new_weights[i] * approx_likelihood_new_parameters[i]
-                sum_of_weights += new_weights[i]
+            new_weights = new_weights * approx_likelihood_new_parameters
+            sum_of_weights = np.sum(new_weights)
+
             new_weights = new_weights / sum_of_weights
 
-            self.logger.info("new_weights : ", new_weights, ", sum_of_weights : ", sum_of_weights)
+            # self.logger.info("new_weights : ", new_weights, ", sum_of_weights : ", sum_of_weights)
+            self.logger.info("sum_of_weights : {}".format(sum_of_weights))
             accepted_parameters = new_parameters
 
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=new_weights)
@@ -876,7 +876,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             # 5: Update the newly computed values
             accepted_parameters = new_parameters
             accepted_weights = new_weights
-            accepted_cov_mat = new_cov_mats
+            accepted_cov_mats = new_cov_mats
 
             self.logger.info("Saving configuration to output journal")
 

From 05a942109f9a9255c77eb49789d4d20d9ede6c0b Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 10 Sep 2020 10:58:37 +0200
Subject: [PATCH 014/106] Fix resampling in SMCABC

---
 abcpy/inferences.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index a94a1ed5..997560e3 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -1231,7 +1231,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 self.logger.info("Weighted resampling")
                 weight = np.exp(-smooth_distances * delta / U)
                 weight = weight / sum(weight)
-                index_resampled = self.rng.choice(np.arange(n_samples, dtype=int), n_samples, replace=1, p=weight)
+                index_resampled = self.rng.choice(n_samples, n_samples, replace=True, p=weight)
                 accepted_parameters = [accepted_parameters[i] for i in index_resampled]
                 smooth_distances = smooth_distances[index_resampled]
 
@@ -2681,8 +2681,11 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             if accepted_y_sim != None and pow(sum(pow(new_weights, 2)), -1) < resample:
                 self.logger.info("Resampling")
                 # Weighted resampling:
-                index_resampled = self.rng.choice(np.arange(n_samples), n_samples, replace=1, p=new_weights)
-                accepted_parameters = accepted_parameters[index_resampled]
+                index_resampled = self.rng.choice(n_samples, n_samples, replace=True, p=new_weights)
+                # accepted_parameters is a list. Then the indexing here does not work:
+                # accepted_parameters = accepted_parameters[index_resampled]
+                # do instead:
+                accepted_parameters = [accepted_parameters[i] for i in index_resampled]  # why don't we use arrays however?
                 new_weights = np.ones(shape=(n_samples), ) * (1.0 / n_samples)
 
             # Update the weights

From 376a56acf48303898a8a40fc1dd45ed6ae7442fa Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 11 Sep 2020 17:39:04 +0200
Subject: [PATCH 015/106] Fix method signatures

---
 abcpy/approx_lhd.py      | 2 +-
 abcpy/jointapprox_lhd.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 2b6b800b..0f4a3acc 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -27,7 +27,7 @@ def __init__(self, statistics_calc):
         raise NotImplemented
 
     @abstractmethod
-    def likelihood(y_obs, y_sim):
+    def likelihood(self, y_obs, y_sim):
         """To be overwritten by any sub-class: should compute the approximate likelihood 
         value given the observed data set y_obs and the data set y_sim simulated from
         model set at the parameter value.
diff --git a/abcpy/jointapprox_lhd.py b/abcpy/jointapprox_lhd.py
index 45028dbf..502b000a 100644
--- a/abcpy/jointapprox_lhd.py
+++ b/abcpy/jointapprox_lhd.py
@@ -24,7 +24,7 @@ def __init__(self, models, approx_lhds):
         raise NotImplementedError
 
     @abstractmethod
-    def likelihood(d1, d2):
+    def likelihood(self, d1, d2):
         """To be overwritten by any sub-class: should calculate the distance between two
         sets of data d1 and d2.
 

From 4cebaeaf34ba09aa07e09b1cf39eace1ba474452 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 11 Sep 2020 18:52:04 +0200
Subject: [PATCH 016/106] Fix requirements: specific version of glmnet
 incompatible with newer sklearn

---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index abc3ad13..9f5dd228 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,7 @@
 numpy
 scipy
 sklearn
-glmnet==2.0.0
+glmnet
 sphinx
 sphinx_rtd_theme 
 coverage

From 7b953abb22342a17c3efa1fc95525ff8461ad527 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 14 Sep 2020 11:46:15 +0200
Subject: [PATCH 017/106] Fix the update of covariance matrix in the inference
 schemes (it was not working before for inference on univariate parameter).

---
 abcpy/inferences.py | 125 ++++++++++++++++++++++++++++++--------------
 1 file changed, 87 insertions(+), 38 deletions(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 997560e3..80b42cec 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -432,7 +432,8 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
                 self.logger.info("Calculateing covariance matrix")
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
                 # Since each entry of new_cov_mats is a numpy array, we can multiply like this
-                accepted_cov_mats = [covFactor * new_cov_mat for new_cov_mat in new_cov_mats]
+                # accepted_cov_mats = [covFactor * new_cov_mat for new_cov_mat in new_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
 
             
             seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32)
@@ -611,6 +612,16 @@ def _calculate_weight(self, theta, npc=None):
                 denominator += self.accepted_parameters_manager.accepted_weights_bds.value()[i, 0] * pdf_value
             return 1.0 * prior_prob / denominator
 
+    def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+        accepted_cov_mats = []
+        for new_cov_mat in new_cov_mats:
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    covFactor * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats
 
 class PMC(BaseLikelihood, InferenceMethod):
     """
@@ -768,8 +779,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
         new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
         # Since each entry of new_cov_mats is a numpy array, we can multiply like this
-
-        accepted_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors,new_cov_mats)]
+        accepted_cov_mats = self._compute_accepted_cov_mats(covFactors, new_cov_mats)
+        # accepted_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors,new_cov_mats)]
 
         self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -796,7 +807,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
                 # Since each entry of new_cov_mats is a numpy array, we can multiply like this
 
-                accepted_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors, new_cov_mats)]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactors, new_cov_mats)
+                # accepted_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors, new_cov_mats)]
 
             self.logger.info("Iteration {} of PMC algorithm".format(aStep))
 
@@ -818,7 +830,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                         new_parameters.append(perturbation_output[1])
                         break
 
-            # 2: calculate approximate lieklihood for new parameters
+            # 2: calculate approximate likelihood for new parameters
             self.logger.info("Calculate approximate likelihood")
             seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=self.n_samples, dtype=np.uint32)
             rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
@@ -869,14 +881,13 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
             new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
             # Since each entry of new_cov_mats is a numpy array, we can multiply like this
-
-            new_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors, new_cov_mats)]
-
+            accepted_cov_mats = self._compute_accepted_cov_mats(covFactors, new_cov_mats)
+            # new_cov_mats = [covFactor * new_cov_mat for covFactor, new_cov_mat in zip(covFactors, new_cov_mats)]
 
             # 5: Update the newly computed values
             accepted_parameters = new_parameters
             accepted_weights = new_weights
-            accepted_cov_mats = new_cov_mats
+            # accepted_cov_mats = new_cov_mats
 
             self.logger.info("Saving configuration to output journal")
 
@@ -965,6 +976,15 @@ def _calculate_weight(self, theta, npc=None):
 
             return 1.0 * prior_prob / denominator
 
+    def _compute_accepted_cov_mats(self, covFactors, new_cov_mats):
+        accepted_cov_mats = []
+        for covFactor, new_cov_mat in zip(covFactors, new_cov_mats):
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    covFactor * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats
 
 class SABC(BaseDiscrepancy, InferenceMethod):
     """
@@ -1133,12 +1153,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-                accepted_cov_mats = []
-                for new_cov_mat in new_cov_mats:
-                    if not(new_cov_mat.size == 1):
-                        accepted_cov_mats.append(beta * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
-                    else:
-                        accepted_cov_mats.append((beta * new_cov_mat + 0.0001 * new_cov_mat).reshape(1,1))
+                accepted_cov_mats = self._compute_accepted_cov_mats(beta, new_cov_mats)
 
                 # Broadcast Accepted Covariance Matrix
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
@@ -1259,12 +1274,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 # Compute Kernel Covariance Matrix and broadcast it
                 self.logger.debug("Compute Kernel Covariance Matrix and broadcast it")
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-                accepted_cov_mats = []
-                for new_cov_mat in new_cov_mats:
-                    if not(new_cov_mat.size == 1):
-                        accepted_cov_mats.append(beta * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
-                    else:
-                        accepted_cov_mats.append((beta * new_cov_mat + 0.0001 * new_cov_mat).reshape(1,1))
+                accepted_cov_mats = self._compute_accepted_cov_mats(beta, new_cov_mats)
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -1289,12 +1299,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
                 # Compute Kernel Covariance Matrix and broadcast it
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-                accepted_cov_mats = []
-                for new_cov_mat in new_cov_mats:
-                    if not(new_cov_mat.size == 1):
-                        accepted_cov_mats.append(beta * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
-                    else:
-                        accepted_cov_mats.append((beta * new_cov_mat + 0.0001 * new_cov_mat).reshape(1,1))
+                accepted_cov_mats = self._compute_accepted_cov_mats(beta, new_cov_mats)
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -1469,6 +1474,18 @@ def _accept_parameter(self, data, npc=None):
 
         return (new_theta, distance, all_parameters, all_distances, index, acceptance, counter)
 
+    def _compute_accepted_cov_mats(self, beta, new_cov_mats):
+        accepted_cov_mats = []
+        for new_cov_mat in new_cov_mats:
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    beta * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((beta * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats
+
+
+
 
 class ABCsubsim(BaseDiscrepancy, InferenceMethod):
     """This base class implements Approximate Bayesian Computation by subset simulation (ABCsubsim) algorithm of [1].
@@ -2005,8 +2022,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-
-                accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+                # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -2034,8 +2051,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-
-                accepted_cov_mats = [covFactor*cov_mat for cov_mat in accepted_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+                # accepted_cov_mats = [covFactor*cov_mat for cov_mat in accepted_cov_mats]
 
             if epsilon[-1] < epsilon_final:
                 self.logger("accepted epsilon {:e} < {:e}"
@@ -2189,6 +2206,16 @@ def _accept_parameter(self, rng, npc=None):
 
         return (self.get_parameters(self.model), distance, index_accept, counter)
 
+    def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+        accepted_cov_mats = []
+        for new_cov_mat in new_cov_mats:
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    covFactor * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats
 
 class APMCABC(BaseDiscrepancy, InferenceMethod):
     """This base class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
@@ -2330,7 +2357,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
 
-                accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+                # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
 
@@ -2400,8 +2428,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
             accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-
-            accepted_cov_mats = [covFactor*cov_mat for cov_mat in accepted_cov_mats]
+            accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+            # accepted_cov_mats = [covFactor*cov_mat for cov_mat in accepted_cov_mats]
 
             # print("INFO: Saving configuration to output journal.")
             if (full_output == 1 and aStep <= steps - 1) or (full_output == 0 and aStep == steps - 1):
@@ -2487,6 +2515,16 @@ def _accept_parameter(self, rng, npc=None):
 
         return (self.get_parameters(self.model), distance, weight, counter)
 
+    def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+        accepted_cov_mats = []
+        for new_cov_mat in new_cov_mats:
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    covFactor * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats
 
 class SMCABC(BaseDiscrepancy, InferenceMethod):
     """This base class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
@@ -2636,8 +2674,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-
-                accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+                # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -2702,8 +2740,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
-
-                accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+                accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
+                # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
 
             # 3: Drawing new perturbed samples using MCMC Kernel
             self.logger.debug("drawing new pertubated samples using mcmc kernel")
@@ -2987,3 +3025,14 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
                 y_sim = self.accepted_y_sim_bds.value()[index]
         distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
         return (self.get_parameters(), y_sim, distance, counter)
+
+    def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
+        accepted_cov_mats = []
+        for new_cov_mat in new_cov_mats:
+            if not (new_cov_mat.size == 1):
+                accepted_cov_mats.append(
+                    covFactor * new_cov_mat + 0.0001 * np.trace(new_cov_mat) * np.eye(new_cov_mat.shape[0]))
+            else:
+                accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
+        return accepted_cov_mats

From 73f0e7093d45a66b5ca910f6c8fd99515c168f55 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 15 Sep 2020 14:52:24 +0200
Subject: [PATCH 018/106] Fix random seeding in the PenLogReg approximate
 likelihood.

---
 abcpy/approx_lhd.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 0f4a3acc..aafce023 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -4,7 +4,7 @@
 
 import numpy as np
 from sklearn.covariance import ledoit_wolf
-from glmnet import LogitNet 
+from glmnet import LogitNet
 
 
 class Approx_likelihood(metaclass = ABCMeta):
@@ -79,7 +79,7 @@ def likelihood(self, y_obs, y_sim):
         # Extract summary statistics from the observed data
         if(self.stat_obs is None or y_obs!=self.data_set):
             self.stat_obs = self.statistics_calc.statistics(y_obs)
-            self.data_set=y_obs
+            self.data_set = y_obs
 
         # Extract summary statistics from the simulated data
         stat_sim = self.statistics_calc.statistics(y_sim)
@@ -115,7 +115,7 @@ class PenLogReg(Approx_likelihood, GraphTools):
 
     Parameters
     ----------
-    statistics_calc : abcpy.stasistics.Statistics
+    statistics_calc : abcpy.statistics.Statistics
         Statistics extractor object that conforms to the Statistics class.
     model : abcpy.models.Model
         Model object that conforms to the Model class.
@@ -137,9 +137,10 @@ def __init__(self, statistics_calc, model, n_simulate, n_folds=10, max_iter = 10
         self.n_folds = n_folds
         self.n_simulate = n_simulate
         self.seed = seed
+        self.rng = np.random.RandomState(seed)
         self.max_iter = max_iter
         # Simulate reference data and extract summary statistics from the reference data
-        self.ref_data_stat = self._simulate_ref_data()[0]
+        self.ref_data_stat = self._simulate_ref_data(rng=self.rng)[0]
 
         self.stat_obs = None
         self.data_set = None

From f4e21a1e41e579516135744367e94dc62c99f0c2 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 30 Sep 2020 15:58:51 +0200
Subject: [PATCH 019/106] Fix groups for cross validation with LogitNet

---
 abcpy/approx_lhd.py      |  8 ++++++--
 abcpy/distances.py       | 11 ++++++++---
 requirements.txt         |  4 ++--
 tests/distances_tests.py |  6 ++++++
 4 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index aafce023..f8eac25c 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -165,8 +165,12 @@ def likelihood(self, y_obs, y_sim):
         # Compute the approximate likelihood for the y_obs given theta
         y = np.append(np.zeros(self.n_simulate),np.ones(self.n_simulate))
         X = np.array(np.concatenate((stat_sim,self.ref_data_stat),axis=0))
-        m = LogitNet(alpha = 1, n_splits = self.n_folds, max_iter = self.max_iter, random_state= self.seed)
-        m = m.fit(X, y)
+        # define here groups for cross-validation:
+        groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(self.n_simulate / self.n_folds)))
+        groups = groups[:self.n_simulate].tolist()
+        groups += groups  # duplicate it as groups need to be defined for both datasets
+        m = LogitNet(alpha=1, n_splits=self.n_folds, max_iter=self.max_iter, random_state=self.seed)
+        m = m.fit(X, y, groups=groups)
         result = np.exp(-np.sum((m.intercept_+np.sum(np.multiply(m.coef_,self.stat_obs),axis=1)),axis=0))
         
         return result
diff --git a/abcpy/distances.py b/abcpy/distances.py
index e04875a8..32484748 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -188,7 +188,8 @@ def __init__(self, statistics):
         self.s1 = None
         self.data_set = None
         self.dataSame = False
-        
+        self.n_folds = 10  # for cross validation in PenLogReg
+
     def distance(self, d1, d2):
         """Calculates the distance between two datasets.
 
@@ -221,8 +222,12 @@ def distance(self, d1, d2):
         label_s2 = np.ones(shape=(len(s2), 1))
         training_set_labels = np.concatenate((label_s1, label_s2), axis=0).ravel()
 
-        m = LogitNet(alpha = 1, n_splits = 10)
-        m = m.fit(training_set_features, training_set_labels)
+        n_simulate = self.s1.shape[0]
+        groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(n_simulate / self.n_folds)))
+        groups = groups[:n_simulate].tolist()
+        groups += groups  # duplicate it as groups need to be defined for both datasets
+        m = LogitNet(alpha=1, n_splits=self.n_folds)  # note we are not using random seed here!
+        m = m.fit(training_set_features, training_set_labels, groups=groups)
         distance = 2.0 * (m.cv_mean_score_[np.where(m.lambda_path_== m.lambda_max_)[0][0]] - 0.5)
     
         return distance
diff --git a/requirements.txt b/requirements.txt
index 9f5dd228..d09c5a54 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,7 @@
 numpy
 scipy
-sklearn
-glmnet
+scikit-learn>=0.23.1
+glmnet>=2.2.1
 sphinx
 sphinx_rtd_theme 
 coverage
diff --git a/tests/distances_tests.py b/tests/distances_tests.py
index ab3ed11d..27ca83b2 100644
--- a/tests/distances_tests.py
+++ b/tests/distances_tests.py
@@ -38,9 +38,11 @@ def setUp(self):
     def test_distance(self):
         d1 = 0.5 * np.random.randn(100,2) - 10
         d2 = 0.5 * np.random.randn(100,2) + 10
+        d3 = 0.5 * np.random.randn(95,2) + 10
 
         d1=d1.tolist()
         d2=d2.tolist()
+        d3=d3.tolist()
         #Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
         self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
@@ -51,6 +53,10 @@ def test_distance(self):
         # equal data sets should have a distance of 0.0
         self.assertEqual(self.distancefunc.distance(d1,d1), 0.0)
         
+        # equal data sets should have a distance of 0.0; check that in case where n_samples is not a multiple of n_folds
+        # in cross validation (10)
+        self.assertEqual(self.distancefunc.distance(d3,d3), 0.0)
+
     def test_dist_max(self):
         self.assertTrue(self.distancefunc.dist_max() == 1.0)
 

From 22fd48fbdd5980c8e2043b5143922cd391fb5721 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 30 Sep 2020 16:45:33 +0200
Subject: [PATCH 020/106] Fix PenLogReg approx lhd: generation of reference
 data was wrong in the way it computed statistics. Fix tests accordingly

---
 abcpy/approx_lhd.py       |  8 +++++++-
 tests/approx_lhd_tests.py | 29 ++++++++++++++++++++++-------
 2 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index f8eac25c..5138214a 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -188,7 +188,13 @@ def _simulate_ref_data(self, rng=np.random.RandomState()):
             ind=0
             while(ref_data_stat[model_index][-1] is None):
                 data = model.forward_simulate(model.get_input_values(), 1, rng=rng)
-                data_stat = self.statistics_calc.statistics(data[0].tolist())
+                # this is wrong, it applies the computation of the statistic independently to the element of data[0]:
+                # print("data[0]", data[0].tolist())
+                # data_stat = self.statistics_calc.statistics(data[0].tolist())
+                # print("stat of data[0]", data_stat)
+                # print("data", data)
+                data_stat = self.statistics_calc.statistics(data)
+                # print("stat of data", data_stat)
                 ref_data_stat[model_index][ind]= data_stat
                 ind+=1
             ref_data_stat[model_index] = np.squeeze(np.asarray(ref_data_stat[model_index]))
diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index b5642319..2cd44dcc 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -11,26 +11,41 @@ def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')
         self.sigma = Uniform([[5.0], [10.0]], name='sigma')
         self.model = Normal([self.mu,self.sigma])
-        self.stat_calc = Identity(degree = 2, cross = 0)
+        self.model_bivariate = Uniform([[0, 0], [1, 1]], name="model")
+        self.stat_calc = Identity(degree = 2, cross = 1)
         self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate = 100, n_folds = 10, max_iter = 100000, seed = 1)
+        self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate = 100, n_folds = 10, max_iter = 100000, seed = 1)
 
     def test_likelihood(self):
-        
+
         #Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.likfun.likelihood, 3.4, [2,1])
         self.assertRaises(TypeError, self.likfun.likelihood, [2,4], 3.4)
 
         # create observed data
-        y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))[0].tolist()
+        y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))
         # create fake simulated data
         self.mu._fixed_values = [1.1]
         self.sigma._fixed_values = [1.0]
         y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
         comp_likelihood = self.likfun.likelihood(y_obs, y_sim)
-        expected_likelihood = 4.3996556327224594
-        # This checks whether it computes a correct value and dimension is right
-        self.assertLess(comp_likelihood - expected_likelihood, 10e-2)
-        
+        expected_likelihood = 7.075779289371343e-07
+        # This checks whether it computes a correct value and dimension is right. Not correct as it does not check the
+        # absolute value:
+        # self.assertLess(comp_likelihood - expected_likelihood, 10e-2)
+        self.assertAlmostEqual(comp_likelihood, expected_likelihood)
+
+        # try now with the bivariate uniform model:
+        y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1,
+                                                                rng=np.random.RandomState(1))
+        y_sim_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 100,
+                                                                rng=np.random.RandomState(1))
+        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, y_sim_bivariate)
+        expected_likelihood_biv = 0.9364479566809435
+        self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
+
+
+
 class SynLikelihoodTests(unittest.TestCase):
     def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')

From 4639d6d6968a684c7a6b1bc1bfb17ec146669753 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 12 Oct 2020 16:28:32 +0200
Subject: [PATCH 021/106] Small fix in PenLogReg: use the log_loss scoring rule
 in LogitNet to choose lambda for Lasso

---
 abcpy/approx_lhd.py       | 2 +-
 tests/approx_lhd_tests.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 5138214a..3d8d2fab 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -169,7 +169,7 @@ def likelihood(self, y_obs, y_sim):
         groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(self.n_simulate / self.n_folds)))
         groups = groups[:self.n_simulate].tolist()
         groups += groups  # duplicate it as groups need to be defined for both datasets
-        m = LogitNet(alpha=1, n_splits=self.n_folds, max_iter=self.max_iter, random_state=self.seed)
+        m = LogitNet(alpha=1, n_splits=self.n_folds, max_iter=self.max_iter, random_state=self.seed, scoring="log_loss")
         m = m.fit(X, y, groups=groups)
         result = np.exp(-np.sum((m.intercept_+np.sum(np.multiply(m.coef_,self.stat_obs),axis=1)),axis=0))
         
diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index 2cd44dcc..39460243 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -29,7 +29,7 @@ def test_likelihood(self):
         self.sigma._fixed_values = [1.0]
         y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
         comp_likelihood = self.likfun.likelihood(y_obs, y_sim)
-        expected_likelihood = 7.075779289371343e-07
+        expected_likelihood = 9.77317308598673e-08
         # This checks whether it computes a correct value and dimension is right. Not correct as it does not check the
         # absolute value:
         # self.assertLess(comp_likelihood - expected_likelihood, 10e-2)

From d75198620bb717bab5c8a18c0ede9b31e68d7a27 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 12 Oct 2020 16:35:58 +0200
Subject: [PATCH 022/106] Small fix in numerical value following previous
 commit

---
 tests/approx_lhd_tests.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index 39460243..bde51a7c 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -41,7 +41,7 @@ def test_likelihood(self):
         y_sim_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 100,
                                                                 rng=np.random.RandomState(1))
         comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, y_sim_bivariate)
-        expected_likelihood_biv = 0.9364479566809435
+        expected_likelihood_biv = 0.999999999999999
         self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
 
 

From 333e2325080cd706f9cdc952925f10af396c68af Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 12 Oct 2020 17:07:42 +0200
Subject: [PATCH 023/106] Solve issue with distances in ABCpy #68

---
 abcpy/inferences.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 535e84ce..58419e51 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -1234,6 +1234,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 index_resampled = self.rng.choice(np.arange(n_samples, dtype=int), n_samples, replace=1, p=weight)
                 accepted_parameters = [accepted_parameters[i] for i in index_resampled]
                 smooth_distances = smooth_distances[index_resampled]
+                distances = distances[index_resampled]
 
                 ## Update U and epsilon:
                 epsilon = epsilon * (1 - delta)

From f8fa455b90f653afe05c74de15942de70be11c83 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 13 Oct 2020 16:00:40 +0200
Subject: [PATCH 024/106] Fix requirements for glmnet 2.0.0

---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index abc3ad13..132a9e95 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,6 @@
 numpy
 scipy
-sklearn
+scikit-learn==0.22.0
 glmnet==2.0.0
 sphinx
 sphinx_rtd_theme 

From 5d483ebe50576312bdac9317c41a355e94736e60 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 14:45:08 +0200
Subject: [PATCH 025/106] Update test values after fixing PMC

---
 tests/inferences_tests.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py
index 257052b7..a88392a9 100644
--- a/tests/inferences_tests.py
+++ b/tests/inferences_tests.py
@@ -96,8 +96,8 @@ def test_sample(self):
         self.assertEqual(mu_sample_shape, (10,1))
         self.assertEqual(sigma_sample_shape, (10,1))
         self.assertEqual(weights_sample_shape, (10,1))
-        self.assertLess(abs(mu_post_mean - (-3.3711206204663764)), 1e-3)
-        self.assertLess(abs(sigma_post_mean - 6.518520667688998), 1e-3)
+        self.assertLess(abs(mu_post_mean - (-3.373004641385251)), 1e-3)
+        self.assertLess(abs(sigma_post_mean - 6.519325027532673), 1e-3)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
@@ -119,8 +119,8 @@ def test_sample(self):
         self.assertEqual(mu_sample_shape, (10,1))
         self.assertEqual(sigma_sample_shape, (10,1))
         self.assertEqual(weights_sample_shape, (10,1))
-        self.assertLess(abs(mu_post_mean - (-2.970827684425406) ), 1e-3)
-        self.assertLess(abs(sigma_post_mean - 6.82165619013458), 1e-3)
+        self.assertLess(abs(mu_post_mean - (-3.2517600952705257)), 1e-3)
+        self.assertLess(abs(sigma_post_mean - 6.9214661382633365), 1e-3)
 
         self.assertFalse(journal.number_of_simulations == 0)
 

From ceadb3729c650d8f5bdae82e5287429c1b21ff95 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 16:43:55 +0200
Subject: [PATCH 026/106] Small fix on checking whether y_obs is same as the
 saved dataset

---
 abcpy/approx_lhd.py | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 3d8d2fab..d15f6be7 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -13,7 +13,7 @@ class Approx_likelihood(metaclass = ABCMeta):
     """
 
     @abstractmethod
-    def __init__(self, statistics_calc):       
+    def __init__(self, statistics_calc):
         """
         The constructor of a sub-class must accept a non-optional statistics
         calculator, which is stored to self.statistics_calc.
@@ -23,7 +23,7 @@ def __init__(self, statistics_calc):
         statistics_calc : abcpy.stasistics.Statistics
             Statistics extractor object that conforms to the Statistics class.
         """
-        
+
         raise NotImplemented
 
     @abstractmethod
@@ -44,7 +44,7 @@ def likelihood(self, y_obs, y_sim):
         float
             Computed approximate likelihood.
         """
-        
+
         raise NotImplemented
 
 
@@ -65,7 +65,6 @@ def __init__(self, statistics_calc):
         self.data_set=None
         self.statistics_calc = statistics_calc
 
-
     def likelihood(self, y_obs, y_sim):
         # print("DEBUG: SynLikelihood.likelihood().")
         if not isinstance(y_obs, list):
@@ -76,8 +75,14 @@ def likelihood(self, y_obs, y_sim):
         if not isinstance(y_sim, list):
             raise TypeError('simulated data is not of allowed types')
 
-        # Extract summary statistics from the observed data
-        if(self.stat_obs is None or y_obs!=self.data_set):
+        # Check whether y_obs is same as the stored dataset.
+        if self.data_set is not None:
+            if len(np.array(y_obs[0]).reshape(-1,)) == 1:
+                self.dataSame = self.data_set == y_obs
+            else:  # otherwise it fails when y_obs[0] is array
+                self.dataSame = all([(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
+
+        if(self.stat_obs is None or self.dataSame is False):
             self.stat_obs = self.statistics_calc.statistics(y_obs)
             self.data_set = y_obs
 
@@ -152,10 +157,16 @@ def likelihood(self, y_obs, y_sim):
             raise TypeError('Observed data is not of allowed types')
         
         if not isinstance(y_sim, list):
-            raise TypeError('simulated data is not of allowed types')            
-        
-        # Extract summary statistics from the observed data
-        if(self.stat_obs is None or self.data_set!=y_obs):
+            raise TypeError('simulated data is not of allowed types')
+
+        # Check whether y_obs is same as the stored dataset.
+        if self.data_set is not None:
+            if len(np.array(y_obs[0]).reshape(-1,)) == 1:
+                self.dataSame = self.data_set == y_obs
+            else:  # otherwise it fails when y_obs[0] is array
+                self.dataSame = all([(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
+
+        if(self.stat_obs is None or self.dataSame is False):
             self.stat_obs = self.statistics_calc.statistics(y_obs)
             self.data_set=y_obs
                 

From 5b2cc99569fbe073ef37d18fefe2a1a092a7dd54 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 17:10:31 +0200
Subject: [PATCH 027/106] Small changes to inferences.py

---
 abcpy/inferences.py | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index eaccaf1b..c1e37025 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -476,9 +476,7 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
             self.logger.info("Calculate weights")
             new_weights_pds = self.backend.map(self._calculate_weight, new_parameters_pds)
             new_weights = np.array(self.backend.collect(new_weights_pds)).reshape(-1, 1)
-            sum_of_weights = 0.0
-            for w in new_weights:
-                sum_of_weights += w
+            sum_of_weights = np.sum(new_weights)
             new_weights = new_weights / sum_of_weights
 
             # The calculation of cov_mats needs the new weights and new parameters
@@ -601,15 +599,13 @@ def _calculate_weight(self, theta, npc=None):
         else:
             prior_prob = self.pdf_of_prior(self.model, theta, 0)
 
-            denominator = 0.0
-
             # Get the mapping of the models to be used by the kernels
             mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(self.accepted_parameters_manager.model)
+            pdf_values = np.array([self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   self.accepted_parameters_manager.accepted_parameters_bds.value()[i],
+                                                   theta) for i in range(self.n_samples)])
+            denominator = np.sum(self.accepted_parameters_manager.accepted_weights_bds.value().reshape(-1) * pdf_values)
 
-            for i in range(0, self.n_samples):
-                pdf_value = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
-                                            self.accepted_parameters_manager.accepted_parameters_bds.value()[i], theta)
-                denominator += self.accepted_parameters_manager.accepted_weights_bds.value()[i, 0] * pdf_value
             return 1.0 * prior_prob / denominator
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
@@ -835,8 +831,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=self.n_samples, dtype=np.uint32)
             rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
             data_arr = []
-            for i in range(len(rng_arr)):
-                data_arr.append([new_parameters[i], rng_arr[i]])
+            data_arr = list(zip(new_parameters, rng_arr))
             data_pds = self.backend.parallelize(data_arr)
 
             approx_likelihood_new_parameters_and_counter_pds = self.backend.map(self._approx_lik_calc, data_pds)
@@ -871,8 +866,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             # The parameters relevant to each kernel have to be used to calculate n_sample times. It is therefore more efficient to broadcast these parameters once, instead of collecting them at each kernel in each step
             self.logger.info("Calculating covariance matrix")
             kernel_parameters = []
-            for kernel in self.kernel.kernels:
-                kernel_parameters.append(self.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models))
+            kernel_parameters = [self.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models) for kernel in self.kernel.kernels]
 
             self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 

From 7c94b31ad6a0fe4db501004b06a905e01e9f7177 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 19:50:59 +0200
Subject: [PATCH 028/106] Some style fixes

---
 abcpy/NN_utilities/algorithms.py              |  18 +-
 abcpy/NN_utilities/trainer.py                 |   3 +-
 abcpy/NN_utilities/utilities.py               |   3 +-
 abcpy/acceptedparametersmanager.py            |  26 +-
 abcpy/approx_lhd.py                           |  62 +--
 abcpy/backends/__init__.py                    |  17 +-
 abcpy/backends/base.py                        |  42 +-
 abcpy/backends/mpi.py                         | 168 +++----
 abcpy/backends/mpimanager.py                  |  22 +-
 abcpy/backends/spark.py                       |  31 +-
 abcpy/continuousmodels.py                     |  81 ++-
 abcpy/discretemodels.py                       |  45 +-
 abcpy/distances.py                            |  29 +-
 abcpy/graphtools.py                           |  97 ++--
 abcpy/inferences.py                           | 472 +++++++++---------
 abcpy/jointapprox_lhd.py                      |  14 +-
 abcpy/jointdistances.py                       |  30 +-
 abcpy/modelselections.py                      |  97 ++--
 abcpy/multilevel.py                           |   5 +-
 abcpy/output.py                               |   2 +-
 abcpy/perturbationkernel.py                   |  63 +--
 abcpy/probabilisticmodels.py                  | 114 ++---
 abcpy/statistics.py                           |   2 +-
 abcpy/statisticslearning.py                   |   2 +-
 .../approx_lhd/pmc_hierarchical_models.py     |  47 +-
 .../backends/apache_spark/pmcabc_gaussian.py  |  36 +-
 examples/backends/dummy/pmcabc_gaussian.py    |  45 +-
 examples/backends/mpi/mpi_model_inferences.py |  69 ++-
 examples/backends/mpi/pmcabc_gaussian.py      |  35 +-
 .../extensions/distances/default_distance.py  |   1 +
 .../models/gaussian_R/gaussian_model.R        |   6 +-
 .../models/gaussian_R/gaussian_model.py       |  49 +-
 .../extensions/models/gaussian_R/graph_ABC.py |  51 +-
 .../pmcabc-gaussian_model_simple.py           |  58 ++-
 .../gaussian_f90/gaussian_model_simple.f90    |  86 ++--
 .../pmcabc-gaussian_model_simple.py           |  63 ++-
 .../pmcabc_gaussian_model_simple.py           |  34 +-
 .../multivariate_normal_kernel.py             |  12 +-
 .../pmcabc_perturbation_kernels.py            |  58 ++-
 ...mcabc_inference_on_multiple_sets_of_obs.py |  49 +-
 .../randomforest_modelselections.py           |  15 +-
 .../pmcabc_gaussian_statistics_learning.py    |  20 +-
 tests/acceptedparametersmanager_tests.py      |  38 +-
 tests/approx_lhd_tests.py                     |  35 +-
 tests/backend_tests_mpi.py                    |  90 ++--
 tests/backend_tests_mpi_model_mpi.py          | 107 ++--
 tests/continuousmodels_tests.py               |  25 +-
 tests/discretemodels_tests.py                 |  19 +-
 tests/distances_tests.py                      |  79 +--
 tests/graphtools_tests.py                     |  41 +-
 tests/inferences_tests.py                     | 297 +++++------
 tests/jointapprox_lhd_tests.py                |  32 +-
 tests/jointdistances_tests.py                 |  44 +-
 tests/modelselections_tests.py                |  32 +-
 tests/output_tests.py                         |  27 +-
 tests/perturbationkernel_tests.py             |  31 +-
 tests/pickle_tests.py                         |  10 +-
 tests/probabilisticmodels_tests.py            | 117 +++--
 tests/statistics_tests.py                     |   2 +
 tests/statisticslearning_tests.py             |  11 +-
 60 files changed, 1692 insertions(+), 1524 deletions(-)

diff --git a/abcpy/NN_utilities/algorithms.py b/abcpy/NN_utilities/algorithms.py
index 738be2f4..dd150772 100644
--- a/abcpy/NN_utilities/algorithms.py
+++ b/abcpy/NN_utilities/algorithms.py
@@ -16,7 +16,8 @@
 
 
 def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_size=16, n_epochs=200,
-                         samples_val=None, similarity_set_val=None, early_stopping=False, epochs_early_stopping_interval=1,
+                         samples_val=None, similarity_set_val=None, early_stopping=False,
+                         epochs_early_stopping_interval=1,
                          start_epoch_early_stopping=10, positive_weight=None, load_all_data_GPU=False, margin=1.,
                          lr=None, optimizer=None, scheduler=None, start_epoch_training=0,
                          optimizer_kwargs={}, scheduler_kwargs={}, loader_kwargs={}):
@@ -39,7 +40,7 @@ def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_siz
 
     if samples_val is not None:
         similarities_dataset_val = Similarities(samples_val, similarity_set_val,
-                                                 "cuda" if cuda and load_all_data_GPU else "cpu")
+                                                "cuda" if cuda and load_all_data_GPU else "cpu")
         pairs_dataset_val = SiameseSimilarities(similarities_dataset_val, positive_weight=positive_weight)
 
     if cuda:
@@ -56,7 +57,7 @@ def contrastive_training(samples, similarity_set, embedding_net, cuda, batch_siz
                                                      **loader_kwargs)
     if samples_val is not None:
         pairs_train_loader_val = torch.utils.data.DataLoader(pairs_dataset_val, batch_size=batch_size, shuffle=False,
-                                                              **loader_kwargs)
+                                                             **loader_kwargs)
     else:
         pairs_train_loader_val = None
 
@@ -112,7 +113,7 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
 
     if samples_val is not None:
         similarities_dataset_val = Similarities(samples_val, similarity_set_val,
-                                                 "cuda" if cuda and load_all_data_GPU else "cpu")
+                                                "cuda" if cuda and load_all_data_GPU else "cpu")
         triplets_dataset_val = TripletSimilarities(similarities_dataset_val)
 
     if cuda:
@@ -129,7 +130,7 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
                                                         **loader_kwargs)
     if samples_val is not None:
         triplets_train_loader_val = torch.utils.data.DataLoader(triplets_dataset_val, batch_size=batch_size,
-                                                                 shuffle=False, **loader_kwargs)
+                                                                shuffle=False, **loader_kwargs)
     else:
         triplets_train_loader_val = None
 
@@ -162,7 +163,8 @@ def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16
 
 
 def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=50, samples_val=None, target_val=None,
-                   early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, load_all_data_GPU=False,
+                   early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10,
+                   load_all_data_GPU=False,
                    lr=1e-3, optimizer=None, scheduler=None, start_epoch_training=0, optimizer_kwargs={},
                    scheduler_kwargs={}, loader_kwargs={}):
     """ Implements the algorithm for the training of a neural network based on regressing the values of the parameters
@@ -184,7 +186,7 @@ def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=
 
     if samples_val is not None:
         dataset_FP_nn_val = ParameterSimulationPairs(samples_val, target_val,
-                                                      "cuda" if cuda and load_all_data_GPU else "cpu")
+                                                     "cuda" if cuda and load_all_data_GPU else "cpu")
 
     if cuda:
         if load_all_data_GPU:
@@ -200,7 +202,7 @@ def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=
 
     if samples_val is not None:
         data_loader_FP_nn_val = torch.utils.data.DataLoader(dataset_FP_nn_val, batch_size=batch_size,
-                                                             shuffle=False, **loader_kwargs)
+                                                            shuffle=False, **loader_kwargs)
     else:
         data_loader_FP_nn_val = None
 
diff --git a/abcpy/NN_utilities/trainer.py b/abcpy/NN_utilities/trainer.py
index 9accc9c9..a408a16a 100644
--- a/abcpy/NN_utilities/trainer.py
+++ b/abcpy/NN_utilities/trainer.py
@@ -1,6 +1,7 @@
-from tqdm import tqdm
 import logging
+
 import torch
+from tqdm import tqdm
 
 
 def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_loader=None, early_stopping=False,
diff --git a/abcpy/NN_utilities/utilities.py b/abcpy/NN_utilities/utilities.py
index 92fb6171..4f5cffc8 100644
--- a/abcpy/NN_utilities/utilities.py
+++ b/abcpy/NN_utilities/utilities.py
@@ -5,9 +5,10 @@
 else:
     has_torch = True
 
-import numpy as np
 import logging
 
+import numpy as np
+
 
 def dist2(x, y):
     """Compute the square of the Euclidean distance between 2 arrays of same length"""
diff --git a/abcpy/acceptedparametersmanager.py b/abcpy/acceptedparametersmanager.py
index 06045403..08bcfc58 100644
--- a/abcpy/acceptedparametersmanager.py
+++ b/abcpy/acceptedparametersmanager.py
@@ -1,6 +1,7 @@
-from abcpy.probabilisticmodels import Hyperparameter, ModelResultingFromOperation
 import numpy as np
 
+from abcpy.probabilisticmodels import Hyperparameter, ModelResultingFromOperation
+
 
 class AcceptedParametersManager:
     def __init__(self, model):
@@ -63,6 +64,7 @@ def update_broadcast(self, backend, accepted_parameters=None, accepted_weights=N
         accepted_cov_mats: np.ndarray
             The accepted covariance matrix to be broadcasted
         """
+
         # Used for Spark backend
         def destroy(bc):
             if bc != None:
@@ -100,22 +102,22 @@ def get_mapping(self, models, is_root=True, index=0):
         mapping = []
 
         for model in models:
-            if(not(model.visited) and not(isinstance(model, Hyperparameter))):
+            if not model.visited and not (isinstance(model, Hyperparameter)):
                 model.visited = True
 
                 # Only parameters that are neither root nor Hyperparameters are included in the mapping
-                if(not(is_root) and not(isinstance(model, ModelResultingFromOperation))):
-                    #for i in range(model.get_output_dimension()):
+                if not is_root and not (isinstance(model, ModelResultingFromOperation)):
+                    # for i in range(model.get_output_dimension()):
                     mapping.append((model, index))
-                    index+=1
+                    index += 1
 
                 for parent in model.get_input_models():
-                    parent_mapping, index = self.get_mapping([parent], is_root= False, index=index)
+                    parent_mapping, index = self.get_mapping([parent], is_root=False, index=index)
                     for element in parent_mapping:
                         mapping.append(element)
 
         # Reset the flags of all models
-        if(is_root):
+        if is_root:
             self._reset_flags()
 
         return [mapping, index]
@@ -144,10 +146,10 @@ def get_accepted_parameters_bds_values(self, models):
         # Add all columns that correspond to desired parameters to the list that is returned
         for model in models:
             for prob_model, index in mapping:
-                if(model==prob_model):
+                if model == prob_model:
                     for i in range(len(self.accepted_parameters_bds.value())):
                         accepted_bds_values[i].append(self.accepted_parameters_bds.value()[i][index])
-        #accepted_bds_values = [np.array(x).reshape(-1, ) for x in accepted_bds_values]
+        # accepted_bds_values = [np.array(x).reshape(-1, ) for x in accepted_bds_values]
 
         return accepted_bds_values
 
@@ -160,11 +162,11 @@ def _reset_flags(self, models=None):
         models: list
             List of abcpy.ProbabilisticModel objects, the models the root models for which, together with their parents, the flags should be reset
         """
-        if(models is None):
+        if models is None:
             models = self.model
 
         for model in models:
             for parent in model.get_input_models():
-                if(parent.visited):
+                if parent.visited:
                     self._reset_flags([parent])
-            model.visited=False
+            model.visited = False
diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index d15f6be7..9340d994 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -1,13 +1,13 @@
 from abc import ABCMeta, abstractmethod
 
-from abcpy.graphtools import GraphTools
-
 import numpy as np
-from sklearn.covariance import ledoit_wolf
 from glmnet import LogitNet
+from sklearn.covariance import ledoit_wolf
 
+from abcpy.graphtools import GraphTools
 
-class Approx_likelihood(metaclass = ABCMeta):
+
+class Approx_likelihood(metaclass=ABCMeta):
     """This abstract base class defines the approximate likelihood 
     function.
     """
@@ -60,9 +60,10 @@ class SynLikelihood(Approx_likelihood):
     [2] O. Ledoit and M. Wolf, A Well-Conditioned Estimator for Large-Dimensional Covariance Matrices,
     Journal of Multivariate Analysis, Volume 88, Issue 2, pages 365-411, February 2004.
     """
+
     def __init__(self, statistics_calc):
         self.stat_obs = None
-        self.data_set=None
+        self.data_set = None
         self.statistics_calc = statistics_calc
 
     def likelihood(self, y_obs, y_sim):
@@ -77,27 +78,28 @@ def likelihood(self, y_obs, y_sim):
 
         # Check whether y_obs is same as the stored dataset.
         if self.data_set is not None:
-            if len(np.array(y_obs[0]).reshape(-1,)) == 1:
+            if len(np.array(y_obs[0]).reshape(-1, )) == 1:
                 self.dataSame = self.data_set == y_obs
             else:  # otherwise it fails when y_obs[0] is array
-                self.dataSame = all([(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
+                self.dataSame = all(
+                    [(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
 
-        if(self.stat_obs is None or self.dataSame is False):
+        if self.stat_obs is None or self.dataSame is False:
             self.stat_obs = self.statistics_calc.statistics(y_obs)
             self.data_set = y_obs
 
         # Extract summary statistics from the simulated data
         stat_sim = self.statistics_calc.statistics(y_sim)
-        
+
         # Compute the mean, robust precision matrix and determinant of precision matrix
-        mean_sim = np.mean(stat_sim,0)
+        mean_sim = np.mean(stat_sim, 0)
         lw_cov_, _ = ledoit_wolf(stat_sim)
         robust_precision_sim = np.linalg.inv(lw_cov_)
         robust_precision_sim_det = np.linalg.det(robust_precision_sim)
         # print("DEBUG: combining.")
-        tmp1 = robust_precision_sim * np.array(self.stat_obs.reshape(-1,1) - mean_sim.reshape(-1,1)).T
-        tmp2 = np.exp(np.sum(-0.5*np.sum(np.array(self.stat_obs-mean_sim) * np.array(tmp1).T, axis = 1)))
-        tmp3 = pow(np.sqrt((1/(2*np.pi)) * robust_precision_sim_det),self.stat_obs.shape[0])
+        tmp1 = robust_precision_sim * np.array(self.stat_obs.reshape(-1, 1) - mean_sim.reshape(-1, 1)).T
+        tmp2 = np.exp(np.sum(-0.5 * np.sum(np.array(self.stat_obs - mean_sim) * np.array(tmp1).T, axis=1)))
+        tmp3 = pow(np.sqrt((1 / (2 * np.pi)) * robust_precision_sim_det), self.stat_obs.shape[0])
         return tmp2 * tmp3
 
 
@@ -111,7 +113,7 @@ class PenLogReg(Approx_likelihood, GraphTools):
     function. For lasso penalized logistic regression we use glmnet of Friedman et.
     al. [2].
     
-    [1] Reference: R. Dutta, J. Corander, S. Kaski, and M. U. Gutmann. Likelihood-free 
+    [1] Reference: R. Dutta, J. Corander, S. Kaski, and M. U. Gutmann. Likelihood-free
     inference by penalised logistic regression. arXiv:1611.10242, Nov. 2016.
     
     [2] Friedman, J., Hastie, T., and Tibshirani, R. (2010). Regularization 
@@ -135,7 +137,8 @@ class PenLogReg(Approx_likelihood, GraphTools):
         deterministic, this seed is used for determining the cv folds. The default value is
         None.
     """
-    def __init__(self, statistics_calc, model, n_simulate, n_folds=10, max_iter = 100000, seed = None):
+
+    def __init__(self, statistics_calc, model, n_simulate, n_folds=10, max_iter=100000, seed=None):
 
         self.model = model
         self.statistics_calc = statistics_calc
@@ -155,27 +158,28 @@ def __init__(self, statistics_calc, model, n_simulate, n_folds=10, max_iter = 10
     def likelihood(self, y_obs, y_sim):
         if not isinstance(y_obs, list):
             raise TypeError('Observed data is not of allowed types')
-        
+
         if not isinstance(y_sim, list):
             raise TypeError('simulated data is not of allowed types')
 
         # Check whether y_obs is same as the stored dataset.
         if self.data_set is not None:
-            if len(np.array(y_obs[0]).reshape(-1,)) == 1:
+            if len(np.array(y_obs[0]).reshape(-1, )) == 1:
                 self.dataSame = self.data_set == y_obs
             else:  # otherwise it fails when y_obs[0] is array
-                self.dataSame = all([(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
+                self.dataSame = all(
+                    [(np.array(self.data_set[i]) == np.array(y_obs[i])).all() for i in range(len(y_obs))])
 
-        if(self.stat_obs is None or self.dataSame is False):
+        if self.stat_obs is None or self.dataSame is False:
             self.stat_obs = self.statistics_calc.statistics(y_obs)
-            self.data_set=y_obs
-                
+            self.data_set = y_obs
+
         # Extract summary statistics from the simulated data
         stat_sim = self.statistics_calc.statistics(y_sim)
-        
+
         # Compute the approximate likelihood for the y_obs given theta
-        y = np.append(np.zeros(self.n_simulate),np.ones(self.n_simulate))
-        X = np.array(np.concatenate((stat_sim,self.ref_data_stat),axis=0))
+        y = np.append(np.zeros(self.n_simulate), np.ones(self.n_simulate))
+        X = np.array(np.concatenate((stat_sim, self.ref_data_stat), axis=0))
         # define here groups for cross-validation:
         groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(self.n_simulate / self.n_folds)))
         groups = groups[:self.n_simulate].tolist()
@@ -193,11 +197,11 @@ def _simulate_ref_data(self, rng=np.random.RandomState()):
         Penlogreg
         """
 
-        ref_data_stat = [[None]*self.n_simulate for i in range(len(self.model))]
+        ref_data_stat = [[None] * self.n_simulate for i in range(len(self.model))]
         self.sample_from_prior(rng=rng)
         for model_index, model in enumerate(self.model):
-            ind=0
-            while(ref_data_stat[model_index][-1] is None):
+            ind = 0
+            while ref_data_stat[model_index][-1] is None:
                 data = model.forward_simulate(model.get_input_values(), 1, rng=rng)
                 # this is wrong, it applies the computation of the statistic independently to the element of data[0]:
                 # print("data[0]", data[0].tolist())
@@ -206,7 +210,7 @@ def _simulate_ref_data(self, rng=np.random.RandomState()):
                 # print("data", data)
                 data_stat = self.statistics_calc.statistics(data)
                 # print("stat of data", data_stat)
-                ref_data_stat[model_index][ind]= data_stat
-                ind+=1
+                ref_data_stat[model_index][ind] = data_stat
+                ind += 1
             ref_data_stat[model_index] = np.squeeze(np.asarray(ref_data_stat[model_index]))
         return ref_data_stat
diff --git a/abcpy/backends/__init__.py b/abcpy/backends/__init__.py
index 936dfbd0..5250100c 100644
--- a/abcpy/backends/__init__.py
+++ b/abcpy/backends/__init__.py
@@ -1,7 +1,7 @@
 from abcpy.backends.base import *
 
 
-def BackendMPI(*args,**kwargs):
+def BackendMPI(*args, **kwargs):
     # import and setup module mpimanager
     import abcpy.backends.mpimanager
     master_node_ranks = [0]
@@ -14,13 +14,14 @@ def BackendMPI(*args,**kwargs):
 
     # import BackendMPI and return and instance
     from abcpy.backends.mpi import BackendMPI
-    return BackendMPI(*args,**kwargs)
+    return BackendMPI(*args, **kwargs)
 
 
-def BackendMPITestHelper(*args,**kwargs):
-    from abcpy.backends.mpi import BackendMPITestHelper 
-    return BackendMPITestHelper(*args,**kwargs)
+def BackendMPITestHelper(*args, **kwargs):
+    from abcpy.backends.mpi import BackendMPITestHelper
+    return BackendMPITestHelper(*args, **kwargs)
 
-def BackendSpark(*args,**kwargs):
-    from  abcpy.backends.spark import BackendSpark
-    return BackendSpark(*args,**kwargs)
\ No newline at end of file
+
+def BackendSpark(*args, **kwargs):
+    from abcpy.backends.spark import BackendSpark
+    return BackendSpark(*args, **kwargs)
diff --git a/abcpy/backends/base.py b/abcpy/backends/base.py
index b74bdcd4..9d74a4e2 100644
--- a/abcpy/backends/base.py
+++ b/abcpy/backends/base.py
@@ -1,6 +1,7 @@
 from abc import ABCMeta, abstractmethod
 
-class Backend(metaclass = ABCMeta):
+
+class Backend(metaclass=ABCMeta):
     """
     This is the base class for every parallelization backend. It essentially
     resembles the map/reduce API from Spark.
@@ -29,9 +30,8 @@ def parallelize(self, list):
         PDS class (parallel data set)
             A reference object that represents the parallelized list
         """
-        
-        raise NotImplementedError
 
+        raise NotImplementedError
 
     @abstractmethod
     def broadcast(self, object):
@@ -48,9 +48,8 @@ def broadcast(self, object):
         BDS class (broadcast data set)
             A reference to the broadcasted object
         """
-        
-        raise NotImplementedError
 
+        raise NotImplementedError
 
     @abstractmethod
     def map(self, func, pds):
@@ -71,9 +70,8 @@ def map(self, func, pds):
         PDS class
             a new parallel data set that contains the result of the map
         """
-        
-        raise NotImplementedError
 
+        raise NotImplementedError
 
     @abstractmethod
     def collect(self, pds):
@@ -90,10 +88,10 @@ def collect(self, pds):
         Python list
             all elements of pds as a list
         """
-        
+
         raise NotImplementedError
 
-    
+
 class PDS:
     """
     The reference class for parallel data sets (PDS).
@@ -108,12 +106,11 @@ class BDS:
     """
     The reference class for broadcast data set (BDS).
     """
-    
+
     @abstractmethod
     def __init__(self):
         raise NotImplementedError
 
-
     @abstractmethod
     def value(self):
         """
@@ -128,11 +125,10 @@ class BackendDummy(Backend):
     anything. It is mainly implemented for testing purpose.
 
     """
-    
+
     def __init__(self):
         pass
 
-    
     def parallelize(self, python_list):
         """
         This actually does nothing: it just wraps the Python list into dummy pds (PDSDummy).
@@ -144,10 +140,9 @@ def parallelize(self, python_list):
         -------        
         PDSDummy (parallel data set)
         """
-        
+
         return PDSDummy(python_list)
 
-    
     def broadcast(self, object):
         """
         This actually does nothing: it just wraps the object into BDSDummy.
@@ -160,10 +155,9 @@ def broadcast(self, object):
         -------        
         BDSDummy class
         """
-        
+
         return BDSDummy(object)
 
-    
     def map(self, func, pds):
         """
         This is a wrapper for the Python internal map function.
@@ -180,12 +174,11 @@ def map(self, func, pds):
         PDSDummy class
             a new pseudo-parallel data set that contains the result of the map
         """
-        
+
         result_map = map(func, pds.python_list)
         result_pds = PDSDummy(list(result_map))
         return result_pds
 
-    
     def collect(self, pds):
         """
         Returns the Python list stored in PDSDummy
@@ -199,35 +192,32 @@ def collect(self, pds):
         Python list
             all elements of pds as a list
         """
-        
+
         return pds.python_list
 
-    
 
 class PDSDummy(PDS):
     """
     This is a wrapper for a Python list to fake parallelization.
     """
-    
+
     def __init__(self, python_list):
         self.python_list = python_list
 
-        
 
 class BDSDummy(BDS):
     """
     This is a wrapper for a Python object to fake parallelization.
     """
-    
+
     def __init__(self, object):
         self.object = object
 
-        
     def value(self):
         return self.object
 
 
-class NestedParallelizationController():
+class NestedParallelizationController:
     @abstractmethod
     def nested_execution(self):
         raise NotImplementedError
diff --git a/abcpy/backends/mpi.py b/abcpy/backends/mpi.py
index 3816becb..c458c9bb 100644
--- a/abcpy/backends/mpi.py
+++ b/abcpy/backends/mpi.py
@@ -1,17 +1,14 @@
 # noinspection PyInterpreter
-import cloudpickle
-import numpy as np
+import logging
 import pickle
 import time
-import logging
 
+import cloudpickle
+import numpy as np
 from mpi4py import MPI
 
-from abcpy.backends import BDS, PDS, Backend, NestedParallelizationController
-
-
 import abcpy.backends.mpimanager
-from mpi4py import MPI
+from abcpy.backends import BDS, PDS, Backend, NestedParallelizationController
 
 
 class NestedParallelizationControllerMPI(NestedParallelizationController):
@@ -27,11 +24,9 @@ def __init__(self, mpi_comm):
         if self.mpi_comm.Get_rank() != 0:
             self.nested_execution()
 
-
     def communicator(self):
         return self.mpi_comm
 
-
     def nested_execution(self):
         rank = self.mpi_comm.Get_rank()
         self.logger.debug("Starting nested loop on rank {}".format(rank))
@@ -61,7 +56,7 @@ def nested_execution(self):
             self.logger.debug("Starting map function {} on rank {}".format(func.__name__, self.mpi_comm.Get_rank()))
             self.func_kwargs['mpi_comm'] = self.mpi_comm
             self.mpi_comm.barrier()
-            self.result = func(*(self.func_args), **(self.func_kwargs))
+            self.result = func(*self.func_args, **self.func_kwargs)
             self.logger.debug("Ending map function on rank {}".format(self.mpi_comm.Get_rank()))
             self.mpi_comm.barrier()
             if self.mpi_comm.Get_rank() == 0:
@@ -91,6 +86,7 @@ def __del__(self):
             self.loop_workers = self.mpi_comm.bcast(self.loop_workers, root=0)
         self.logger.debug(">>>>>>>> NPC stopped on rank {}".format(rank))
 
+
 class BackendMPIScheduler(Backend):
     """Defines the behavior of the scheduler process
 
@@ -99,7 +95,7 @@ class BackendMPIScheduler(Backend):
 
     """
 
-    #Define some operation codes to make it more readable
+    # Define some operation codes to make it more readable
     OP_PARALLELIZE, OP_MAP, OP_COLLECT, OP_BROADCAST, OP_DELETEPDS, OP_DELETEBDS, OP_FINISH = [1, 2, 3, 4, 5, 6, 7]
     finalized = False
 
@@ -112,21 +108,20 @@ def __init__(self, chunk_size=1):
             execution teams
        """
 
-        #Initialize the current_pds_id and bds_id
+        # Initialize the current_pds_id and bds_id
         self.__current_pds_id = 0
         self.__current_bds_id = 0
 
-        #Initialize a BDS store for both scheduler & team.
+        # Initialize a BDS store for both scheduler & team.
         self.bds_store = {}
         self.pds_store = {}
 
-        #Initialize a store for the pds data that 
-        #.. hasn't been sent to the teams yet
+        # Initialize a store for the pds data that
+        # .. hasn't been sent to the teams yet
         self.pds_pending_store = {}
 
         self.chunk_size = chunk_size
 
-
     def __command_teams(self, command, data):
         """Tell teams to enter relevant execution block
         This method handles the sending of the command to the teams
@@ -143,24 +138,24 @@ def __command_teams(self, command, data):
         """
 
         if command == self.OP_PARALLELIZE:
-            #In parallelize we receive data as (pds_id)
+            # In parallelize we receive data as (pds_id)
             data_packet = (command, data[0])
 
         elif command == self.OP_MAP:
-            #In map we receive data as (pds_id,pds_id_new,func)
-            #Use cloudpickle to dump the function into a string.
-            function_packed = cloudpickle.dumps(data[2],pickle.HIGHEST_PROTOCOL)
+            # In map we receive data as (pds_id,pds_id_new,func)
+            # Use cloudpickle to dump the function into a string.
+            function_packed = cloudpickle.dumps(data[2], pickle.HIGHEST_PROTOCOL)
             data_packet = (command, data[0], data[1], function_packed)
 
         elif command == self.OP_BROADCAST:
             data_packet = (command, data[0])
 
         elif command == self.OP_COLLECT:
-            #In collect we receive data as (pds_id)
+            # In collect we receive data as (pds_id)
             data_packet = (command, data[0])
 
         elif command == self.OP_DELETEPDS or command == self.OP_DELETEBDS:
-            #In deletepds we receive data as (pds_id) or bds_id
+            # In deletepds we receive data as (pds_id) or bds_id
             data_packet = (command, data[0])
 
         elif command == self.OP_FINISH:
@@ -168,8 +163,6 @@ def __command_teams(self, command, data):
 
         _ = self.mpimanager.get_scheduler_communicator().bcast(data_packet, root=0)
 
-
-
     def __generate_new_pds_id(self):
         """
         This method generates a new pds_id to associate a PDS with it's remote counterpart
@@ -184,7 +177,6 @@ def __generate_new_pds_id(self):
         self.__current_pds_id += 1
         return self.__current_pds_id
 
-
     def __generate_new_bds_id(self):
         """
         This method generates a new bds_id to associate a BDS with it's remote counterpart
@@ -199,7 +191,6 @@ def __generate_new_bds_id(self):
         self.__current_bds_id += 1
         return self.__current_bds_id
 
-
     def parallelize(self, python_list):
         """
         This method distributes the list on the available teams and returns a
@@ -225,14 +216,14 @@ def parallelize(self, python_list):
         pds_id = self.__generate_new_pds_id()
         self.__command_teams(self.OP_PARALLELIZE, (pds_id,))
 
-        #Don't send any data. Just keep it as a queue we're going to pop.
+        # Don't send any data. Just keep it as a queue we're going to pop.
         self.pds_store[pds_id] = list(python_list)
 
         pds = PDSMPI([], pds_id, self)
 
         return pds
 
-    def orchestrate_map(self,pds_id):
+    def orchestrate_map(self, pds_id):
         """Orchestrates the teams to perform a map function
         
         This works by keeping track of the teams who haven't finished executing,
@@ -240,16 +231,17 @@ def orchestrate_map(self,pds_id):
         responding to them with the data and then sending them a Sentinel
         signalling that they can exit.
         """
-        is_map_done = [True if i in self.mpimanager.get_scheduler_node_ranks() else False for i in range(self.mpimanager.get_scheduler_size())]
+        is_map_done = [True if i in self.mpimanager.get_scheduler_node_ranks() else False for i in
+                       range(self.mpimanager.get_scheduler_size())]
         status = MPI.Status()
 
-        #Copy it to the pending. This is so when scheduler accesses
-        #the PDS data it's not empty.
+        # Copy it to the pending. This is so when scheduler accesses
+        # the PDS data it's not empty.
         self.pds_pending_store[pds_id] = list(self.pds_store[pds_id])
 
-        #While we have some ranks that haven't finished
-        while sum(is_map_done)<self.mpimanager.get_scheduler_size():
-            #Wait for a reqest from anyone
+        # While we have some ranks that haven't finished
+        while sum(is_map_done) < self.mpimanager.get_scheduler_size():
+            # Wait for a reqest from anyone
             data_request = self.mpimanager.get_scheduler_communicator().recv(
                 source=MPI.ANY_SOURCE,
                 tag=MPI.ANY_TAG,
@@ -257,26 +249,26 @@ def orchestrate_map(self,pds_id):
             )
             request_from_rank = status.source
 
-            if data_request!=pds_id:
+            if data_request != pds_id:
                 print("Ignoring stale PDS data request from",
-                    request_from_rank,":",data_request,"/",pds_id)
+                      request_from_rank, ":", data_request, "/", pds_id)
                 continue
 
-            #Pointer so we don't have to keep doing dict lookups
+            # Pointer so we don't have to keep doing dict lookups
             current_pds_items = self.pds_pending_store[pds_id]
             num_current_pds_items = len(current_pds_items)
 
-            #Everyone's already exhausted all the data.
+            # Everyone's already exhausted all the data.
             # Send a sentinel and mark the node as finished
             if num_current_pds_items == 0:
                 self.mpimanager.get_scheduler_communicator().send(None, dest=request_from_rank, tag=pds_id)
                 is_map_done[request_from_rank] = True
             else:
-                #Create the chunk of data to send. Pop off items and tag them with an id.
+                # Create the chunk of data to send. Pop off items and tag them with an id.
                 # so we can sort them later
                 chunk_to_send = []
                 for i in range(self.chunk_size):
-                    chunk_to_send+=[(num_current_pds_items-i,current_pds_items.pop())]
+                    chunk_to_send += [(num_current_pds_items - i, current_pds_items.pop())]
                     self.mpimanager.get_scheduler_communicator().send(chunk_to_send, dest=request_from_rank, tag=pds_id)
 
     def map(self, func, pds):
@@ -299,10 +291,10 @@ def map(self, func, pds):
         """
 
         # Tell the teams to enter the map() with the current pds_id & func.
-        #Get pds_id of dataset we want to operate on
+        # Get pds_id of dataset we want to operate on
         pds_id = pds.pds_id
 
-        #Generate a new pds_id to be used by the teams for the resultant PDS
+        # Generate a new pds_id to be used by the teams for the resultant PDS
         pds_id_new = self.__generate_new_pds_id()
 
         data = (pds_id, pds_id_new, func)
@@ -313,7 +305,6 @@ def map(self, func, pds):
 
         return pds_res
 
-
     def collect(self, pds):
         """
         Gather the pds from all the teams,
@@ -333,11 +324,11 @@ def collect(self, pds):
         # Tell the teams to enter collect with the pds's pds_id
         self.__command_teams(self.OP_COLLECT, (pds.pds_id,))
 
-        #all_data = self.world_communicator.gather(pds.python_list, root=0)
+        # all_data = self.world_communicator.gather(pds.python_list, root=0)
         all_data = self.mpimanager.get_scheduler_communicator().gather(pds.python_list, root=0)
 
-        #Initialize lists to accumulate results
-        all_data_indices,all_data_items = [],[]
+        # Initialize lists to accumulate results
+        all_data_indices, all_data_items = [], []
 
         for node_data in all_data:
             for index, item in node_data:
@@ -346,12 +337,11 @@ def collect(self, pds):
                 all_data_indices.append(index)
                 all_data_items.append(item)
 
-        #Sort the accumulated data according to the indices we tagged
-        #them with when distributing 
+        # Sort the accumulated data according to the indices we tagged
+        # them with when distributing
         rdd_sorted = [all_data_items[i] for i in np.argsort(all_data_indices)]
         return rdd_sorted
 
-
     def broadcast(self, value):
         """
         Sends a data to all leaders and workers
@@ -367,7 +357,6 @@ def broadcast(self, value):
         bds = BDSMPI(value, bds_id, self)
         return bds
 
-
     def delete_remote_pds(self, pds_id):
         """
         A public function for the PDS objects on the scheduler to call when they go out of
@@ -379,10 +368,9 @@ def delete_remote_pds(self, pds_id):
             A pds_id identifying the remote PDS on the teams to delete.
         """
 
-        if  not self.finalized:
+        if not self.finalized:
             self.__command_teams(self.OP_DELETEPDS, (pds_id,))
 
-
     def delete_remote_bds(self, bds_id):
         """
         Public function for the BDS objects on the scheduler to call when they go
@@ -395,13 +383,12 @@ def delete_remote_bds(self, bds_id):
             A bds_id identifying the remote BDS on the teams to delete.
         """
 
-        if  not self.finalized:
-            #The scheduler deallocates it's BDS data. Explicit because
-            #.. bds_store and BDSMPI object are disconnected.
+        if not self.finalized:
+            # The scheduler deallocates it's BDS data. Explicit because
+            # .. bds_store and BDSMPI object are disconnected.
             del backend.bds_store[bds_id]
             self.__command_teams(self.OP_DELETEBDS, (bds_id,))
 
-
     def __del__(self):
         """
         Overriding the delete function to explicitly call MPI.finalize().
@@ -410,10 +397,10 @@ def __del__(self):
         finalize when they die.
         """
 
-        #Tell the teams they can exit gracefully.
+        # Tell the teams they can exit gracefully.
         self.__command_teams(self.OP_FINISH, None)
 
-        #Finalize the connection because the teams should have finished.
+        # Finalize the connection because the teams should have finished.
         MPI.Finalize()
         self.finalized = True
 
@@ -441,12 +428,12 @@ def run_function(self, function_packed, data_item):
         func = cloudpickle.loads(function_packed)
         res = None
         try:
-            if(self.mpimanager.get_model_size() > 1):
+            if self.mpimanager.get_model_size() > 1:
                 npc = NestedParallelizationControllerMPI(self.mpimanager.get_model_communicator())
                 if self.mpimanager.get_model_communicator().Get_rank() == 0:
                     self.logger.debug("Executing map function on master rank 0.")
                     res = func(data_item, npc=npc)
-                del(npc)
+                del npc
             else:
                 res = func(data_item)
         except Exception as e:
@@ -454,7 +441,6 @@ def run_function(self, function_packed, data_item):
             res = type(e)(msg + str(e))
         return res
 
-
     def __worker_run(self):
         """
         Workers enter an infinite loop and waits for instructions from their leader
@@ -463,14 +449,14 @@ def __worker_run(self):
             data = self.mpimanager.get_model_communicator().bcast(None, root=0)
             op = data[0]
             if op == self.OP_MAP:
-                #Receive data from scheduler of the model
+                # Receive data from scheduler of the model
                 function_packed = self.mpimanager.get_model_communicator().bcast(None, root=0)[0]
                 data_item = self.mpimanager.get_model_communicator().bcast(None, root=0)[0]
                 self.run_function(function_packed, data_item)
             elif op == self.OP_BROADCAST:
                 self._bds_id = data[1]
                 self.broadcast(None)
-            elif op == self.OP_FINISH:  
+            elif op == self.OP_FINISH:
                 quit()
             else:
                 raise Exception("worker model received unknown command code")
@@ -501,14 +487,11 @@ class BackendMPILeader(BackendMPIWorker):
 
     OP_PARALLELIZE, OP_MAP, OP_COLLECT, OP_BROADCAST, OP_DELETEPDS, OP_DELETEBDS, OP_FINISH = [1, 2, 3, 4, 5, 6, 7]
 
-
     def __init__(self):
         """ No parameter, just call leader_run """
         self.logger = logging.getLogger(__name__)
         self.__leader_run()
 
-
-
     def __leader_run(self):
         """
         This method is the infinite loop a leader enters directly from init.
@@ -548,8 +531,8 @@ def __leader_run(self):
                 pds_id, pds_id_result, function_packed = data[1:]
                 self._rec_pds_id, self._rec_pds_id_result = pds_id, pds_id_result
 
-                #Enter the map so we can grab data and perform the func.
-                #Func sent before and not during for performance reasons
+                # Enter the map so we can grab data and perform the func.
+                # Func sent before and not during for performance reasons
                 pds_res = self.map(function_packed)
 
                 # Store the result in a newly gnerated PDS pds_id
@@ -557,7 +540,7 @@ def __leader_run(self):
 
             elif op == self.OP_BROADCAST:
                 self._bds_id = data[1]
-                #relay command and data into model communicator
+                # relay command and data into model communicator
                 self.mpimanager.get_model_communicator().bcast(data, root=0)
                 self.broadcast(None)
 
@@ -584,7 +567,6 @@ def __leader_run(self):
             else:
                 raise Exception("team received unknown command code")
 
-
     def __get_received_pds_id(self):
         """
         Function to retrieve the pds_id(s) we received from the scheduler to associate
@@ -602,7 +584,6 @@ def __leader_run_function(self, function_packed, data_item):
         self.mpimanager.get_model_communicator().bcast([data_item], root=0)
         return self.run_function(function_packed, data_item)
 
-
     def parallelize(self):
         pass
 
@@ -625,29 +606,28 @@ def map(self, function_packed):
 
         map_start = time.time()
 
-        #Get the PDS id we operate on and the new one to store the result in
+        # Get the PDS id we operate on and the new one to store the result in
         pds_id, pds_id_new = self.__get_received_pds_id()
 
         rdd = []
         while True:
-            #Ask for a chunk of data since it's free
+            # Ask for a chunk of data since it's free
             data_chunks = self.mpimanager.get_scheduler_communicator().sendrecv(pds_id, 0, pds_id)
-            
-            #If it receives a sentinel, it's done and it can exit
+
+            # If it receives a sentinel, it's done and it can exit
             if data_chunks is None:
                 break
 
-            #Accumulate the indicess and *processed* chunks
+            # Accumulate the indicess and *processed* chunks
             for chunk in data_chunks:
-                data_index,data_item = chunk
+                data_index, data_item = chunk
                 res = self.__leader_run_function(function_packed, data_item)
-                rdd+=[(data_index,res)]
+                rdd += [(data_index, res)]
 
         pds_res = PDSMPI(rdd, pds_id_new, self)
 
         return pds_res
 
-
     def collect(self, pds):
         """
         Gather the pds from all the leaders,
@@ -664,12 +644,11 @@ def collect(self, pds):
             all elements of pds as a list
         """
 
-        #Send the data we have back to the scheduler
+        # Send the data we have back to the scheduler
         _ = self.mpimanager.get_scheduler_communicator().gather(pds.python_list, root=0)
 
 
-
-class BackendMPITeam(BackendMPILeader if abcpy.backends.mpimanager.get_mpi_manager().is_leader() else  BackendMPIWorker):
+class BackendMPITeam(BackendMPILeader if abcpy.backends.mpimanager.get_mpi_manager().is_leader() else BackendMPIWorker):
     """
     A team is compounded by workers and a leader. One process per team is a leader, others are workers
     """
@@ -677,20 +656,19 @@ class BackendMPITeam(BackendMPILeader if abcpy.backends.mpimanager.get_mpi_manag
     OP_PARALLELIZE, OP_MAP, OP_COLLECT, OP_BROADCAST, OP_DELETEPDS, OP_DELETEBDS, OP_FINISH = [1, 2, 3, 4, 5, 6, 7]
 
     def __init__(self):
-        #Define the vars that will hold the pds ids received from scheduler to operate on
+        # Define the vars that will hold the pds ids received from scheduler to operate on
         self._rec_pds_id = None
         self._rec_pds_id_result = None
 
-        #Initialize a BDS store for both scheduler & team.
+        # Initialize a BDS store for both scheduler & team.
         self.bds_store = {}
 
-        #print("In BackendMPITeam, rank : ", self.rank, ", model_rank_global : ", globals()['model_rank_global'])
+        # print("In BackendMPITeam, rank : ", self.rank, ", model_rank_global : ", globals()['model_rank_global'])
 
         self.logger = logging.getLogger(__name__)
         super().__init__()
 
 
-
 class BackendMPI(BackendMPIScheduler if abcpy.backends.mpimanager.get_mpi_manager().is_scheduler() else BackendMPITeam):
     """A backend parallelized by using MPI
 
@@ -718,13 +696,12 @@ def __init__(self, scheduler_node_ranks=[0], process_per_model=1):
         if self.mpimanager.get_world_size() < 2:
             raise ValueError('A minimum of 2 ranks are required for the MPI backend')
 
-        #Set the global backend
+        # Set the global backend
         globals()['backend'] = self
 
-        #Call the appropriate constructors and pass the required data
+        # Call the appropriate constructors and pass the required data
         super().__init__()
 
-
     def size(self):
         """ Returns world size """
         return self.mpimanager.get_world_size()
@@ -733,20 +710,17 @@ def scheduler_node_ranks(self):
         """ Returns scheduler node ranks """
         return self.mpimanager.get_scheduler_node_ranks()
 
-
     @staticmethod
     def disable_nested(mpi_comm):
         if mpi_comm.Get_rank() != 0:
             mpi_comm.Barrier()
 
-
     @staticmethod
     def enable_nested(mpi_comm):
         if mpi_comm.Get_rank() == 0:
             mpi_comm.Barrier()
 
 
-
 class PDSMPI(PDS):
     """
     This is an MPI wrapper for a Python parallel data set.
@@ -765,7 +739,7 @@ def __del__(self):
         try:
             self.backend_obj.delete_remote_pds(self.pds_id)
         except AttributeError:
-            #Catch "delete_remote_pds not defined" for teams and ignore.
+            # Catch "delete_remote_pds not defined" for teams and ignore.
             pass
 
 
@@ -775,8 +749,8 @@ class BDSMPI(BDS):
     """
 
     def __init__(self, object, bds_id, backend_obj):
-        #The BDS data is no longer saved in the BDS object.
-        #It will access & store the data only from the current backend
+        # The BDS data is no longer saved in the BDS object.
+        # It will access & store the data only from the current backend
         self.bds_id = bds_id
         backend.bds_store[self.bds_id] = object
 
@@ -795,13 +769,15 @@ def __del__(self):
         try:
             backend.delete_remote_bds(self.bds_id)
         except AttributeError:
-            #Catch "delete_remote_pds not defined" for teams and ignore.
+            # Catch "delete_remote_pds not defined" for teams and ignore.
             pass
 
+
 class BackendMPITestHelper:
     """
     Helper function for some of the test cases to be able to access and verify class members.
     """
+
     def check_pds(self, k):
         """Checks if a PDS exists in the pds data store. Used to verify deletion and creation
         """
diff --git a/abcpy/backends/mpimanager.py b/abcpy/backends/mpimanager.py
index 17a7b33c..ad4a91cf 100644
--- a/abcpy/backends/mpimanager.py
+++ b/abcpy/backends/mpimanager.py
@@ -1,8 +1,8 @@
 from mpi4py import MPI
-import sys
 
 __mpimanager = None
 
+
 class MPIManager(object):
     """Defines the behavior of the slaves/worker processes
 
@@ -28,13 +28,14 @@ def __init__(self, scheduler_node_ranks=[0], process_per_model=1):
         self._size = self._world_communicator.Get_size()
         self._rank = self._world_communicator.Get_rank()
 
-        #Construct the appropriate communicators for resource allocation to models
-        #There is one communicator for scheduler nodes
-        #And one communicator per model
+        # Construct the appropriate communicators for resource allocation to models
+        # There is one communicator for scheduler nodes
+        # And one communicator per model
         self._scheduler_node_ranks = scheduler_node_ranks
         self._process_per_model = process_per_model
-        self._model_color = int(((self._rank - sum(i < self._rank for i in scheduler_node_ranks)) / process_per_model) + 1)
-        if(self._rank in scheduler_node_ranks):
+        self._model_color = int(
+            ((self._rank - sum(i < self._rank for i in scheduler_node_ranks)) / process_per_model) + 1)
+        if self._rank in scheduler_node_ranks:
             self._model_color = 0
         self._model_communicator = MPI.COMM_WORLD.Split(self._model_color, self._rank)
         self._model_size = self._model_communicator.Get_size()
@@ -42,7 +43,7 @@ def __init__(self, scheduler_node_ranks=[0], process_per_model=1):
 
         # create a communicator to broadcast instructions to slaves
         self._scheduler_color = 1
-        if(self._model_color == 0 or self._model_rank == 0):
+        if self._model_color == 0 or self._model_rank == 0:
             self._scheduler_color = 0
         self._scheduler_communicator = MPI.COMM_WORLD.Split(self._scheduler_color, self._rank)
         self._scheduler_size = self._scheduler_communicator.Get_size()
@@ -62,7 +63,6 @@ def __init__(self, scheduler_node_ranks=[0], process_per_model=1):
             self._team = True
             self._worker = True
 
-
     def is_scheduler(self):
         ''' Tells if the process is a scheduler '''
         return self._scheduler
@@ -119,15 +119,17 @@ def get_scheduler_communicator(self):
         ''' Returns the scheduler communicator '''
         return self._scheduler_communicator
 
+
 def get_mpi_manager():
     ''' Return the instance of mpimanager
     Creates one with default parameters is not already existing '''
     global mpimanager
-    if mpimanager == None :
+    if mpimanager == None:
         create_mpi_manager([0], 1)
     return mpimanager
 
+
 def create_mpi_manager(scheduler_node_ranks, process_per_model):
     ''' Creates the instance of mpimanager with given parameters '''
     global mpimanager
-    mpimanager = MPIManager(scheduler_node_ranks, process_per_model)
\ No newline at end of file
+    mpimanager = MPIManager(scheduler_node_ranks, process_per_model)
diff --git a/abcpy/backends/spark.py b/abcpy/backends/spark.py
index 33d960a9..f266ecc9 100644
--- a/abcpy/backends/spark.py
+++ b/abcpy/backends/spark.py
@@ -1,12 +1,12 @@
-
 from abcpy.backends import Backend, PDS, BDS
 
+
 class BackendSpark(Backend):
     """
     A parallelization backend for Apache Spark. It is essetially a wrapper for
     the required Spark functionality.
     """
-    
+
     def __init__(self, sparkContext, parallelism=4):
         """
         Initialize the backend with an existing and configured SparkContext.
@@ -21,7 +21,6 @@ def __init__(self, sparkContext, parallelism=4):
         self.sc = sparkContext
         self.parallelism = parallelism
 
-
     def parallelize(self, python_list):
         """
         This is a wrapper of pyspark.SparkContext.parallelize().
@@ -36,12 +35,11 @@ def parallelize(self, python_list):
         PDSSpark class (parallel data set)
             A reference object that represents the parallelized list
         """
-        
+
         rdd = self.sc.parallelize(python_list, self.parallelism)
         pds = PDSSpark(rdd)
         return pds
 
-
     def broadcast(self, object):
         """
         This is a wrapper for pyspark.SparkContext.broadcast().
@@ -55,12 +53,11 @@ def broadcast(self, object):
         BDSSpark class (broadcast data set)
             A reference to the broadcasted object
         """
-        
+
         bcv = self.sc.broadcast(object)
         bds = BDSSpark(bcv)
         return bds
 
-
     def map(self, func, pds):
         """
         This is a wrapper for pyspark.rdd.map()
@@ -76,12 +73,11 @@ def map(self, func, pds):
         PDSSpark class
             a new parallel data set that contains the result of the map
         """
-        
+
         rdd = pds.rdd.map(func)
         new_pds = PDSSpark(rdd)
         return new_pds
 
-
     def collect(self, pds):
         """
         A wrapper for pyspark.rdd.collect()
@@ -95,17 +91,16 @@ def collect(self, pds):
         Python list
             all elements of pds as a list
         """
-        
+
         python_list = pds.rdd.collect()
         return python_list
 
-    
-    
+
 class PDSSpark(PDS):
     """
     This is a wrapper for Apache Spark RDDs.
     """
-    
+
     def __init__(self, rdd):
         """
         Returns
@@ -113,16 +108,15 @@ def __init__(self, rdd):
         rdd: pyspark.rdd
             initialize with an Spark RDD
         """
-        
-        self.rdd = rdd
 
+        self.rdd = rdd
 
 
 class BDSSpark(BDS):
     """
     This is a wrapper for Apache Spark Broadcast variables.
     """
-    
+
     def __init__(self, bcv):
         """
         Parameters
@@ -130,9 +124,8 @@ def __init__(self, bcv):
         bcv: pyspark.broadcast.Broadcast
             Initialize with a Spark broadcast variable
         """
-        
-        self.bcv = bcv
 
+        self.bcv = bcv
 
     def value(self):
         """
@@ -141,5 +134,5 @@ def value(self):
         object
             returns the referenced object that was broadcasted.
         """
-        
+
         return self.bcv.value
diff --git a/abcpy/continuousmodels.py b/abcpy/continuousmodels.py
index ca32a10e..3b31760f 100644
--- a/abcpy/continuousmodels.py
+++ b/abcpy/continuousmodels.py
@@ -1,9 +1,9 @@
-from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, Hyperparameter, InputConnector
 import numpy as np
-
-from numbers import Number
-from scipy.stats import multivariate_normal, norm
 from scipy.special import gamma
+from scipy.stats import multivariate_normal, norm
+
+from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
+
 
 class Uniform(ProbabilisticModel, Continuous):
     def __init__(self, parameters, name='Uniform'):
@@ -23,7 +23,7 @@ def __init__(self, parameters, name='Uniform'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Uniform has to be of type list.')
-        if len(parameters)<2:
+        if len(parameters) < 2:
             raise ValueError('Input for Uniform has to be of length 2.')
         if not isinstance(parameters[0], list):
             raise TypeError('Each boundary for Uniform has to be of type list.')
@@ -46,11 +46,10 @@ def _check_input(self, input_values):
 
         # test whether lower bound is not greater than upper bound
         for j in range(self.get_output_dimension()):
-            if (input_values[j] > input_values[j+self.get_output_dimension()]):
+            if input_values[j] > input_values[j + self.get_output_dimension()]:
                 return False
         return True
 
-
     def _check_output(self, parameters):
         """
         Checks parameter values given as fixed values. Returns False iff a lower bound value is larger than a
@@ -59,12 +58,11 @@ def _check_output(self, parameters):
 
         for i in range(self.get_output_dimension()):
             lower_value = self.get_input_connector()[i]
-            upper_value = self.get_input_connector()[i+self.get_output_dimension()]
+            upper_value = self.get_input_connector()[i + self.get_output_dimension()]
             if parameters[i] < lower_value or parameters[i] > upper_value:
                 return False
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples from a uniform distribution using the current values for each probabilistic model from which the model derives.
@@ -86,14 +84,12 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
 
         samples = np.zeros(shape=(k, self.get_output_dimension()))
         for j in range(0, self.get_output_dimension()):
-            samples[:, j] = rng.uniform(input_values[j], input_values[j+self.get_output_dimension()], k)
-        return [np.array(x).reshape(-1,) for x in samples]
-
+            samples[:, j] = rng.uniform(input_values[j], input_values[j + self.get_output_dimension()], k)
+        return [np.array(x).reshape(-1, ) for x in samples]
 
     def get_output_dimension(self):
         return self._dimension
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x.
@@ -115,7 +111,7 @@ def pdf(self, input_values, x):
         lower_bound = input_values[:self.get_output_dimension()]
         upper_bound = input_values[self.get_output_dimension():]
 
-        if (np.product(np.greater_equal(x, np.array(lower_bound)) * np.less_equal(x, np.array(upper_bound)))):
+        if np.product(np.greater_equal(x, np.array(lower_bound)) * np.less_equal(x, np.array(upper_bound))):
             pdf_value = 1. / np.product(np.array(upper_bound) - np.array(lower_bound))
         else:
             pdf_value = 0.
@@ -141,7 +137,7 @@ def __init__(self, parameters, name='Normal'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Normal has to be of type list.')
-        if len(parameters)<2:
+        if len(parameters) < 2:
             raise ValueError('Input for Normal has to be of length 2.')
 
         input_parameters = InputConnector.from_list(parameters)
@@ -159,14 +155,12 @@ def _check_input(self, input_values):
             return False
         return True
 
-
     def _check_output(self, parameters):
         """
         Checks parameter values that are given as fixed values.
         """
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples from a normal distribution using the current values for each probabilistic model from which the model derives.
@@ -189,15 +183,13 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         mu = input_values[0]
         sigma = input_values[1]
         result = np.array(rng.normal(mu, sigma, k))
-        return [np.array([x]).reshape(-1,) for x in result]
-
+        return [np.array([x]).reshape(-1, ) for x in result]
 
     def get_output_dimension(self):
         return 1
         ## Why does the following not work here?
         ## return self._dimension
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x.
@@ -218,7 +210,7 @@ def pdf(self, input_values, x):
 
         mu = input_values[0]
         sigma = input_values[1]
-        pdf = norm(mu,sigma).pdf(x)
+        pdf = norm(mu, sigma).pdf(x)
         self.calculated_pdf = pdf
         return pdf
 
@@ -241,7 +233,7 @@ def __init__(self, parameters, name='StudentT'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for StudentT has to be of type list.')
-        if len(parameters)<2:
+        if len(parameters) < 2:
             raise ValueError('Input for StudentT has to be of length 2.')
 
         input_parameters = InputConnector.from_list(parameters)
@@ -269,9 +261,8 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
 
         mean = input_values[0]
         df = input_values[1]
-        result = np.array((rng.standard_t(df,k)+mean))
-        return [np.array([x]).reshape(-1,) for x in result]
-
+        result = np.array((rng.standard_t(df, k) + mean))
+        return [np.array([x]).reshape(-1, ) for x in result]
 
     def _check_input(self, input_values):
         """
@@ -296,7 +287,6 @@ def get_output_dimension(self):
         ## Why does the following not work here?
         ## return self._dimension
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x.
@@ -316,8 +306,8 @@ def pdf(self, input_values, x):
         """
 
         df = input_values[1]
-        x-=input_values[0] #divide by std dev if we include that
-        pdf = gamma((df+1)/2)/(np.sqrt(df*np.pi)*gamma(df/2)*(1+x**2/df)**((df+1)/2))
+        x -= input_values[0]  # divide by std dev if we include that
+        pdf = gamma((df + 1) / 2) / (np.sqrt(df * np.pi) * gamma(df / 2) * (1 + x ** 2 / df) ** ((df + 1) / 2))
         self.calculated_pdf = pdf
         return pdf
 
@@ -344,7 +334,7 @@ def __init__(self, parameters, name='Multivariate Normal'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Multivariate Normal has to be of type list.')
-        if len(parameters)<2:
+        if len(parameters) < 2:
             raise ValueError('Input for Multivariate Normal has to be of length 2.')
 
         mean = parameters[0]
@@ -365,10 +355,10 @@ def _check_input(self, input_values):
         # Test whether input in compatible
         dim = self._dimension
         param_ctn = len(input_values)
-        if param_ctn != dim+dim**2:
+        if param_ctn != dim + dim ** 2:
             return False
 
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim,dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
 
         # Check whether the covariance matrix is symmetric
         if not np.allclose(cov, cov.T, atol=1e-3):
@@ -382,7 +372,6 @@ def _check_input(self, input_values):
 
         return True
 
-
     def _check_output(self, parameters):
         """
         Checks parameter values that are given as fixed values.
@@ -390,7 +379,6 @@ def _check_output(self, parameters):
 
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples from a multivariate normal distribution using the current values for each probabilistic model from which the
@@ -413,15 +401,13 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
 
         dim = self.get_output_dimension()
         mean = np.array(input_values[0:dim])
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim, dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
         result = rng.multivariate_normal(mean, cov, k)
-        return [np.array([result[i,:]]).reshape(-1,) for i in range(k)]
-
+        return [np.array([result[i, :]]).reshape(-1, ) for i in range(k)]
 
     def get_output_dimension(self):
         return self._dimension
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x. Commonly used to determine whether perturbed parameters
@@ -443,7 +429,7 @@ def pdf(self, input_values, x):
         dim = self._dimension
         # Extract parameters
         mean = np.array(input_values[0:dim])
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim, dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
 
         pdf = multivariate_normal(mean, cov).pdf(x)
         self.calculated_pdf = pdf
@@ -468,7 +454,7 @@ def __init__(self, parameters, name='MultiStudentT'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Multivariate StudentT has to be of type list.')
-        if len(parameters)<3:
+        if len(parameters) < 3:
             raise ValueError('Input for Multivariate Student T has to be of length 3.')
         if not isinstance(parameters[0], list):
             raise TypeError('Input for mean of Multivariate Student T has to be of type list.')
@@ -494,12 +480,12 @@ def _check_input(self, input_values):
 
         dim = self._dimension
         param_ctn = len(input_values)
-        if param_ctn > dim+dim**2+1 or param_ctn < dim+dim**2+1:
+        if param_ctn > dim + dim ** 2 + 1 or param_ctn < dim + dim ** 2 + 1:
             return False
 
         # Extract parameters
         mean = np.array(input_values[0:dim])
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim, dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
         df = input_values[-1]
 
         # Check whether the covariance matrix is symmetric
@@ -518,7 +504,6 @@ def _check_input(self, input_values):
 
         return True
 
-
     def _check_output(self, parameters):
         """
         Checks parameter values given as fixed values.
@@ -549,10 +534,10 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         # Extract input_parameters
         dim = self.get_output_dimension()
         mean = np.array(input_values[0:dim])
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim, dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
         df = input_values[-1]
 
-        if (df == np.inf):
+        if df == np.inf:
             chisq = 1.0
         else:
             chisq = rng.chisquare(df, k) / df
@@ -561,11 +546,9 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         result = (mean + np.divide(mvn, np.sqrt(chisq)))
         return [np.array([result[i, :]]).reshape(-1, ) for i in range(k)]
 
-
     def get_output_dimension(self):
         return self._dimension
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x.
@@ -588,14 +571,14 @@ def pdf(self, input_values, x):
 
         # Extract parameters
         mean = np.array(input_values[0:dim])
-        cov = np.array(input_values[dim:dim+dim**2]).reshape((dim, dim))
+        cov = np.array(input_values[dim:dim + dim ** 2]).reshape((dim, dim))
         df = input_values[-1]
 
-        p=len(mean)
+        p = len(mean)
         numerator = gamma((df + p) / 2)
         denominator = gamma(df / 2) * pow(df * np.pi, p / 2.) * np.sqrt(abs(np.linalg.det(cov)))
         normalizing_const = numerator / denominator
         tmp = 1 + 1 / df * np.dot(np.dot(np.transpose(x - mean), np.linalg.inv(cov)), (x - mean))
         density = normalizing_const * pow(tmp, -((df + p) / 2.))
         self.calculated_pdf = density
-        return density
\ No newline at end of file
+        return density
diff --git a/abcpy/discretemodels.py b/abcpy/discretemodels.py
index 858ab18c..dca61bf7 100644
--- a/abcpy/discretemodels.py
+++ b/abcpy/discretemodels.py
@@ -1,9 +1,9 @@
-from abcpy.probabilisticmodels import ProbabilisticModel, Discrete, Hyperparameter, InputConnector
-
 import numpy as np
 from scipy.special import comb
 from scipy.stats import poisson, bernoulli
 
+from abcpy.probabilisticmodels import ProbabilisticModel, Discrete, InputConnector
+
 
 class Bernoulli(Discrete, ProbabilisticModel):
     def __init__(self, parameters, name='Bernoulli'):
@@ -20,7 +20,7 @@ def __init__(self, parameters, name='Bernoulli'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Bernoulli has to be of type list.')
-        if len(parameters)!=1:
+        if len(parameters) != 1:
             raise ValueError('Input for Bernoulli has to be of length 1.')
 
         self._dimension = len(parameters)
@@ -28,7 +28,6 @@ def __init__(self, parameters, name='Bernoulli'):
         super(Bernoulli, self).__init__(input_parameters, name)
         self.visited = False
 
-
     def _check_input(self, input_values):
         """
         Checks parameter values sampled from the parents.
@@ -37,12 +36,11 @@ def _check_input(self, input_values):
             return False
 
         # test whether probability is in the interval [0,1]
-        if input_values[0]<0 or input_values[0]>1:
-           return False
+        if input_values[0] < 0 or input_values[0] > 1:
+            return False
 
         return True
 
-
     def _check_output(self, parameters):
         """
         Checks parameter values given as fixed values. Returns False iff it is not an integer
@@ -51,7 +49,6 @@ def _check_output(self, parameters):
             return False
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples from the bernoulli distribution associtated with the probabilistic model.
@@ -74,11 +71,9 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         result = np.array(rng.binomial(1, input_values[0], k))
         return [np.array([x]) for x in result]
 
-
     def get_output_dimension(self):
         return self._dimension
 
-
     def pmf(self, input_values, x):
         """Evaluates the probability mass function at point x.
 
@@ -118,7 +113,7 @@ def __init__(self, parameters, name='Binomial'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Binomial has to be of type list.')
-        if len(parameters)!=2:
+        if len(parameters) != 2:
             raise ValueError('Input for Binomial has to be of length 2.')
 
         self._dimension = 1
@@ -150,13 +145,11 @@ def _check_input(self, input_values):
 
         return True
 
-
     def _check_output(self, parameters):
         if not isinstance(parameters[0], (int, np.int32, np.int64)):
             return False
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples from a binomial distribution using the current values for each probabilistic model from which the model derives.
@@ -179,11 +172,9 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         result = rng.binomial(input_values[0], input_values[1], k)
         return [np.array([x]) for x in result]
 
-
     def get_output_dimension(self):
         return self._dimension
 
-
     def pmf(self, input_values, x):
         """
         Calculates the probability mass function at point x.
@@ -205,10 +196,10 @@ def pmf(self, input_values, x):
         x = int(x)
         n = input_values[0]
         p = input_values[1]
-        if(x>n):
+        if x > n:
             pmf = 0
         else:
-            pmf = comb(n,x)*pow(p,x)*pow((1-p),(n-x))
+            pmf = comb(n, x) * pow(p, x) * pow((1 - p), (n - x))
         self.calculated_pmf = pmf
         return pmf
 
@@ -228,7 +219,7 @@ def __init__(self, parameters, name='Poisson'):
 
         if not isinstance(parameters, list):
             raise TypeError('Input for Poisson has to be of type list.')
-        if len(parameters)!=1:
+        if len(parameters) != 1:
             raise ValueError('Input for Poisson has to be of length 1.')
 
         self._dimension = 1
@@ -236,7 +227,6 @@ def __init__(self, parameters, name='Poisson'):
         super(Poisson, self).__init__(input_parameters, name)
         self.visited = False
 
-
     def _check_input(self, input_values):
         """Raises an error iff more than one parameter are given or the parameter given is smaller than 0."""
 
@@ -244,18 +234,16 @@ def _check_input(self, input_values):
             return False
 
         # test whether the parameter is smaller than 0
-        if input_values[0]<0:
-           return False
+        if input_values[0] < 0:
+            return False
 
         return True
 
-
     def _check_output(self, parameters):
         if not isinstance(parameters[0], (int, np.int32, np.int64)):
             return False
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """
         Samples k values from the defined possion distribution.
@@ -280,11 +268,9 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
         result = rng.poisson(int(input_values[0]), k)
         return [np.array([x]) for x in result]
 
-
     def get_output_dimension(self):
         return self._dimension
 
-
     def pmf(self, input_values, x):
         """Calculates the probability mass function of the distribution at point x.
 
@@ -306,7 +292,6 @@ def pmf(self, input_values, x):
         return pmf
 
 
-
 class DiscreteUniform(Discrete, ProbabilisticModel):
     def __init__(self, parameters, name='DiscreteUniform'):
         """This class implements a probabilistic model following a Discrete Uniform distribution.
@@ -339,7 +324,8 @@ def _check_input(self, input_values):
         lowerbound = input_values[0]  # Lower bound
         upperbound = input_values[1]  # Upper bound
 
-        if not isinstance(lowerbound, (int, np.int64, np.int32, np.int16)) or not isinstance(upperbound, (int, np.int64, np.int32, np.int16)) or lowerbound >= upperbound:
+        if not isinstance(lowerbound, (int, np.int64, np.int32, np.int16)) or not isinstance(upperbound, (
+        int, np.int64, np.int32, np.int16)) or lowerbound >= upperbound:
             return False
         return True
 
@@ -369,8 +355,8 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
         list: [np.ndarray]
             A list containing the sampled values as np-array.
         """
-        result = np.array(rng.randint(input_values[0], input_values[1]+1, size=k, dtype=np.int64))
-        return [np.array([x]).reshape(-1,) for x in result]
+        result = np.array(rng.randint(input_values[0], input_values[1] + 1, size=k, dtype=np.int64))
+        return [np.array([x]).reshape(-1, ) for x in result]
 
     def get_output_dimension(self):
         return self._dimension
@@ -397,4 +383,3 @@ def pmf(self, input_values, x):
             pmf = 0
         self.calculated_pmf = pmf
         return pmf
-
diff --git a/abcpy/distances.py b/abcpy/distances.py
index 32484748..56e4d24c 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -3,14 +3,13 @@
 import numpy as np
 from glmnet import LogitNet
 from sklearn import linear_model
-from scipy import stats
 
 
 class Distance(metaclass = ABCMeta):
     """This abstract base class defines how the distance between the observed and
     simulated data should be implemented.    
     """
-    
+
     @abstractmethod
     def __init__(self, statistics_calc):
         """The constructor of a sub-class must accept a non-optional statistics
@@ -22,10 +21,10 @@ def __init__(self, statistics_calc):
         statistics_calc : abcpy.stasistics.Statistics 
             Statistics extractor object that conforms to the Statistics class.
         """
-        
+
         raise NotImplementedError
 
-    
+
     @abstractmethod
     def distance(d1, d2):
         """To be overwritten by any sub-class: should calculate the distance between two
@@ -41,7 +40,7 @@ def distance(d1, d2):
         ..., sXn] using the statistics object. See _calculate_summary_stat method.
         
         2. Calculate the mutual desired distance, here denoted by -, between the
-        statstics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
+        statistics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
         
         Important: any sub-class must not calculate the distance between data sets
         d1 and d2 directly. This is the reason why any sub-class must be
@@ -59,10 +58,10 @@ def distance(d1, d2):
         numpy.ndarray
             The distance between the two input data sets.
         """
-                
+
         raise NotImplementedError
 
-    
+
     @abstractmethod
     def dist_max(self):
         """To be overwritten by sub-class: should return maximum possible value of the
@@ -77,7 +76,7 @@ def dist_max(self):
         numpy.float
             The maximal possible value of the desired distance function.
         """
-        
+
         raise NotImplementedError
 
 
@@ -109,7 +108,7 @@ class Euclidean(Distance):
 
     The maximum value of the distance is np.inf.
     """
-    
+
     def __init__(self, statistics):
         self.statistics_calc = statistics
 
@@ -118,7 +117,7 @@ def __init__(self, statistics):
         self.s1 = None
         self.data_set = None
         self.dataSame = False
-        
+
     def distance(self, d1, d2):
         """Calculates the distance between two datasets.
 
@@ -155,7 +154,7 @@ def distance(self, d1, d2):
 
         return dist.mean()
 
-    
+
     def dist_max(self):
         return np.inf
 
@@ -244,7 +243,7 @@ class LogReg(Distance):
     [1] Gutmann, M., Dutta, R., Kaski, S., and Corander, J. (2014). Statistical 
     inference of intractable generative models via classification. arXiv:1407.4981.
     """
-    
+
     def __init__(self, statistics):
         self.statistics_calc = statistics
 
@@ -252,7 +251,7 @@ def __init__(self, statistics):
         self.s1 = None
         self.data_set = None
         self.dataSame = False
-        
+
     def distance(self, d1, d2):
         """Calculates the distance between two datasets.
 
@@ -280,7 +279,7 @@ def distance(self, d1, d2):
             self.s1 = self.statistics_calc.statistics(d1)
             self.data_set = d1
         s2 = self.statistics_calc.statistics(d2)
-        
+
         # compute distance between the statistics
         training_set_features = np.concatenate((self.s1, s2), axis=0)
         label_s1 = np.zeros(shape=(len(self.s1), 1))
@@ -295,4 +294,4 @@ def distance(self, d1, d2):
         return distance
 
     def dist_max(self):
-        return 1.0
\ No newline at end of file
+        return 1.0
diff --git a/abcpy/graphtools.py b/abcpy/graphtools.py
index 05b2f913..f7e80905 100644
--- a/abcpy/graphtools.py
+++ b/abcpy/graphtools.py
@@ -1,8 +1,9 @@
 import numpy as np
+
 from abcpy.probabilisticmodels import Hyperparameter, ModelResultingFromOperation
 
 
-class GraphTools():
+class GraphTools:
     """This class implements all methods that will be called recursively on the graph structure."""
 
     def sample_from_prior(self, model=None, rng=np.random.RandomState()):
@@ -17,10 +18,10 @@ def sample_from_prior(self, model=None, rng=np.random.RandomState()):
         rng: Random number generator
             Defines the random number generator to be used
         """
-        if(model is None):
+        if model is None:
             model = self.model
         # If it was at some point not possible to sample (due to incompatible parameter values provided by the parents), we start from scratch
-        while(not(self._sample_from_prior(model, rng=rng))):
+        while not (self._sample_from_prior(model, rng=rng)):
             self._reset_flags(model)
 
         # At the end of the algorithm, are flags are reset such that new methods can act on the graph freely
@@ -48,16 +49,17 @@ def _sample_from_prior(self, models, is_not_root=False, was_accepted=True, rng=n
         """
 
         # If it was so far possible to sample parameters for all nodes, the current node as well as its parents are sampled, using depth-first search
-        if(was_accepted):
+        if was_accepted:
             for model in models:
                 for parent in model.get_input_models():
-                    if(not(parent.visited)):
+                    if not parent.visited:
                         parent.visited = True
-                        was_accepted = self._sample_from_prior([parent], is_not_root = True, was_accepted=was_accepted, rng=rng)
-                        if(not(was_accepted)):
+                        was_accepted = self._sample_from_prior([parent], is_not_root=True, was_accepted=was_accepted,
+                                                               rng=rng)
+                        if not was_accepted:
                             return False
 
-                if(is_not_root and not(model._forward_simulate_and_store_output(rng=rng))):
+                if is_not_root and not (model._forward_simulate_and_store_output(rng=rng)):
                     return False
 
                 model.visited = True
@@ -132,51 +134,51 @@ def _recursion_pdf_of_prior(self, models, parameters, mapping=None, is_root=True
             The resulting pdf,as well as the next index to be considered in the parameters list.
         """
         # At the beginning of calculation, obtain the mapping
-        if(is_root):
+        if is_root:
             mapping, garbage_index = self._get_mapping()
 
         # The pdf of each root model is first calculated seperately
-        result = [1.]*len(models)
+        result = [1.] * len(models)
 
         for i, model in enumerate(models):
             # If the model is not a root model, the pdf of this model, given the prior, should be calculated
-            if(not(is_root) and not(isinstance(model, ModelResultingFromOperation))):
+            if not is_root and not (isinstance(model, ModelResultingFromOperation)):
                 # Define a helper list which will contain the parameters relevant to the current model for pdf calculation
                 relevant_parameters = []
 
                 for mapped_model, model_index in mapping:
-                    if(mapped_model==model):
+                    if mapped_model == model:
                         parameter_index = model_index
-                        #for j in range(model.get_output_dimension()):
+                        # for j in range(model.get_output_dimension()):
                         relevant_parameters.append(parameters[parameter_index])
-                        #parameter_index+=1
+                        # parameter_index+=1
                         break
-                if(len(relevant_parameters)==1):
+                if len(relevant_parameters) == 1:
                     relevant_parameters = relevant_parameters[0]
                 else:
                     relevant_parameters = np.array(relevant_parameters)
             else:
-                relevant_parameters=[]
+                relevant_parameters = []
 
             # Mark whether the parents of each model have been visited before for this model to avoid repeated calculation.
             visited_parents = [False for j in range(len(model.get_input_models()))]
             # For each parent, the pdf of this parent has to be calculated as well.
             for parent_index, parent in enumerate(model.get_input_models()):
                 # Only calculate the pdf if the parent has never been visited for this model
-                if(not(visited_parents[parent_index])):
+                if not (visited_parents[parent_index]):
                     pdf = self._recursion_pdf_of_prior([parent], parameters, mapping=mapping, is_root=False)
                     input_models = model.get_input_models()
                     for j in range(len(input_models)):
                         if input_models[j][0] == parent:
-                            visited_parents[j]=True
+                            visited_parents[j] = True
                     result[i] *= pdf
-            if(not(is_root)):
-                if(model.calculated_pdf is None):
-                    result[i] *= model.pdf(model.get_input_values(),relevant_parameters)
+            if not is_root:
+                if model.calculated_pdf is None:
+                    result[i] *= model.pdf(model.get_input_values(), relevant_parameters)
                 else:
-                    result[i] *= 1 
+                    result[i] *= 1
 
-        # Multiply the pdfs of all roots together to give an overall pdf.
+                    # Multiply the pdfs of all roots together to give an overall pdf.
         temporary_result = result
         result = 1.
         for individual_result in temporary_result:
@@ -202,27 +204,28 @@ def _get_mapping(self, models=None, index=0, is_not_root=False):
             A list containing two entries. The first entry corresponds to the mapping of the root models, including their parents. The second entry corresponds to the next index to be considered in a parameter list.
         """
 
-        if(models is None):
+        if models is None:
             models = self.model
 
         mapping = []
 
         for model in models:
             # If this model corresponds to an unvisited free parameter, add it to the mapping
-            if(is_not_root and not(model.visited) and not(isinstance(model, Hyperparameter)) and not(isinstance(model, ModelResultingFromOperation))):
+            if is_not_root and not model.visited and not (isinstance(model, Hyperparameter)) and not (
+            isinstance(model, ModelResultingFromOperation)):
                 mapping.append((model, index))
-                index+= 1 #model.get_output_dimension()
+                index += 1  # model.get_output_dimension()
             # Add all parents to the mapping, if applicable
             for parent in model.get_input_models():
                 parent_mapping, index = self._get_mapping([parent], index=index, is_not_root=True)
-                parent.visited=True
+                parent.visited = True
                 for mappings in parent_mapping:
                     mapping.append(mappings)
 
-            model.visited=True
+            model.visited = True
 
         # At the end of the algorithm, reset all flags such that another method can act on the graph freely.
-        if(not(is_not_root)):
+        if not is_not_root:
             self._reset_flags()
 
         return [mapping, index]
@@ -241,12 +244,11 @@ def _get_names_and_parameters(self):
         return_value = []
 
         for model, index in mapping:
-
-            return_value.append((model.name, self.accepted_parameters_manager.get_accepted_parameters_bds_values([model])))
+            return_value.append(
+                (model.name, self.accepted_parameters_manager.get_accepted_parameters_bds_values([model])))
 
         return return_value
 
-
     def get_parameters(self, models=None, is_root=True):
         """
         Returns the current values of all free parameters in the model. Commonly used before perturbing the parameters
@@ -290,7 +292,6 @@ def get_parameters(self, models=None, is_root=True):
 
         return parameters
 
-
     def set_parameters(self, parameters, models=None, index=0, is_root=True):
         """
         Sets new values for the currently used values of each random variable.
@@ -320,11 +321,11 @@ def set_parameters(self, parameters, models=None, index=0, is_root=True):
         for model in models:
             # New parameters should only be set in case we are not at the root
             if not is_root and not isinstance(model, ModelResultingFromOperation):
-                #new_output_values = np.array(parameters[index:index + model.get_output_dimension()])
-                new_output_values = np.array(parameters[index]).reshape(-1,)
+                # new_output_values = np.array(parameters[index:index + model.get_output_dimension()])
+                new_output_values = np.array(parameters[index]).reshape(-1, )
                 if not model.set_output_values(new_output_values):
                     return [False, index]
-                index += 1 #model.get_output_dimension()
+                index += 1  # model.get_output_dimension()
                 model.visited = True
 
             # New parameters for all parents are set using a depth-first search
@@ -339,12 +340,12 @@ def set_parameters(self, parameters, models=None, index=0, is_root=True):
             model.visited = True
 
         # At the end of the algorithm, are flags are reset such that new methods can act on the graph freely
-        if(is_root):
+        if is_root:
             self._reset_flags()
 
         return [True, index]
 
-    def get_correct_ordering(self, parameters_and_models, models=None, is_root = True):
+    def get_correct_ordering(self, parameters_and_models, models=None, is_root=True):
         """
         Orders the parameters returned by a kernel in the order required by the graph.
         Commonly used when perturbing the parameters.
@@ -364,29 +365,30 @@ def get_correct_ordering(self, parameters_and_models, models=None, is_root = Tru
         ordered_parameters = []
 
         # If we are at the root, we set models to the model attribute of the inference method
-        if(is_root):
-            models=self.model
+        if is_root:
+            models = self.model
 
         for model in models:
-            if(not(model.visited)):
+            if not model.visited:
                 model.visited = True
 
                 # Check all entries in parameters_and_models to determine whether the current model is contained within it
                 for corresponding_model, parameter in parameters_and_models:
-                    if(corresponding_model==model):
+                    if corresponding_model == model:
                         for param in parameter:
                             ordered_parameters.append(param)
                         break
 
                 # Recursively order all the parents of the current model
                 for parent in model.get_input_models():
-                    if(not(parent.visited)):
-                        parent_ordering = self.get_correct_ordering(parameters_and_models, models=[parent],is_root=False)
+                    if not parent.visited:
+                        parent_ordering = self.get_correct_ordering(parameters_and_models, models=[parent],
+                                                                    is_root=False)
                         for parent_parameters in parent_ordering:
                             ordered_parameters.append(parent_parameters)
 
         # At the end of the algorithm, are flags are reset such that new methods can act on the graph freely
-        if(is_root):
+        if is_root:
             self._reset_flags()
 
         return ordered_parameters
@@ -409,9 +411,10 @@ def simulate(self, n_samples_per_param, rng=np.random.RandomState(), npc=None):
             parameters_compatible = model._check_input(model.get_input_values())
             if parameters_compatible:
                 if npc is not None and npc.communicator().Get_size() > 1:
-                    simulation_result = npc.run_nested(model.forward_simulate, model.get_input_values(), n_samples_per_param, rng=rng)
+                    simulation_result = npc.run_nested(model.forward_simulate, model.get_input_values(),
+                                                       n_samples_per_param, rng=rng)
                 else:
-                    simulation_result = model.forward_simulate(model.get_input_values(),n_samples_per_param, rng=rng)
+                    simulation_result = model.forward_simulate(model.get_input_values(), n_samples_per_param, rng=rng)
                 result.append(simulation_result)
             else:
                 return None
diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index c1e37025..2d2f00f2 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -1,10 +1,9 @@
 import copy
 import logging
-import numpy as np
 import time
-import sys
+from abc import abstractproperty
 
-from abc import ABCMeta, abstractmethod, abstractproperty
+import numpy as np
 from scipy import optimize
 
 from abcpy.acceptedparametersmanager import *
@@ -17,7 +16,7 @@
 from abcpy.utils import cached
 
 
-class InferenceMethod(GraphTools, metaclass = ABCMeta):
+class InferenceMethod(GraphTools, metaclass=ABCMeta):
     """
         This abstract base class represents an inference method.
 
@@ -68,7 +67,7 @@ def n_samples_per_param(self):
         raise NotImplementedError
 
 
-class BaseMethodsWithKernel(metaclass = ABCMeta):
+class BaseMethodsWithKernel(metaclass=ABCMeta):
     """
     This abstract base class represents inference methods that have a kernel.
     """
@@ -78,7 +77,7 @@ def kernel(self):
         """To be overwritten by any sub-class: an attribute specifying the transition or perturbation kernel."""
         raise NotImplementedError
 
-    def perturb(self, column_index, epochs = 10, rng=np.random.RandomState()):
+    def perturb(self, column_index, epochs=10, rng=np.random.RandomState()):
         """
         Perturbs all free parameters, given the current weights.
         Commonly used during inference.
@@ -111,7 +110,7 @@ def perturb(self, column_index, epochs = 10, rng=np.random.RandomState()):
             accepted, last_index = self.set_parameters(correctly_ordered_parameters, 0)
             if accepted:
                 break
-            current_epoch+=1
+            current_epoch += 1
 
         if current_epoch == 10:
             return [False]
@@ -119,17 +118,18 @@ def perturb(self, column_index, epochs = 10, rng=np.random.RandomState()):
         return [True, correctly_ordered_parameters]
 
 
-class BaseLikelihood(InferenceMethod, BaseMethodsWithKernel, metaclass = ABCMeta):
+class BaseLikelihood(InferenceMethod, BaseMethodsWithKernel, metaclass=ABCMeta):
     """
     This abstract base class represents inference methods that use the likelihood.
     """
+
     @abstractproperty
     def likfun(self):
         """To be overwritten by any sub-class: an attribute specifying the likelihood function to be used."""
         raise NotImplementedError
 
 
-class BaseDiscrepancy(InferenceMethod, BaseMethodsWithKernel, metaclass = ABCMeta):
+class BaseDiscrepancy(InferenceMethod, BaseMethodsWithKernel, metaclass=ABCMeta):
     """
     This abstract base class represents inference methods using descrepancy.
     """
@@ -232,7 +232,7 @@ def sample(self, observations, n_samples, n_samples_per_param, epsilon, full_out
         accepted_parameters, distances, counter = [list(t) for t in zip(*accepted_parameters_distances_counter)]
 
         for count in counter:
-            self.simulation_counter+=count
+            self.simulation_counter += count
 
         distances = np.array(distances)
 
@@ -275,18 +275,17 @@ def _sample_parameter(self, rng, npc=None):
             self.sample_from_prior(rng=rng)
             theta = self.get_parameters(self.model)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
-            if(y_sim is not None):
+            counter += 1
+            if y_sim is not None:
                 distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
                 self.logger.debug("distance after {:4d} simulations: {:e}".format(
                     counter, distance))
             else:
                 distance = self.distance.dist_max()
-        self.logger.debug(
-                "Needed {:4d} simulations to reach distance {:e} < epsilon = {:e}".
-                format(counter, distance, float(self.epsilon))
-                )
-        return (theta, distance, counter)
+        self.logger.debug("Needed {:4d} simulations to reach distance {:e} < epsilon = {:e}".format(counter, distance,
+                                                                                                    float(
+                                                                                                        self.epsilon)))
+        return theta, distance, counter
 
 
 class PMCABC(BaseDiscrepancy, InferenceMethod):
@@ -320,18 +319,17 @@ class PMCABC(BaseDiscrepancy, InferenceMethod):
     kernel = None
     rng = None
 
-    #default value, set so that testing works
+    # default value, set so that testing works
     n_samples = 2
     n_samples_per_param = None
 
     backend = None
 
-
     def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Linear combination distance using all the distances for each individual models
         self.distance = LinearCombination(root_models, distances)
-        if(kernel is None):
+        if kernel is None:
 
             mapping, garbage_index = self._get_mapping()
             models = []
@@ -342,14 +340,14 @@ def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.kernel = kernel
         self.backend = backend
         self.rng = np.random.RandomState(seed)
-        self.logger = logging.getLogger(__name__) 
+        self.logger = logging.getLogger(__name__)
 
         self.accepted_parameters_manager = AcceptedParametersManager(self.model)
 
-        self.simulation_counter=0
-
+        self.simulation_counter = 0
 
-    def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples_per_param = 1, epsilon_percentile = 10, covFactor = 2, full_output=0, journal_file = None):
+    def sample(self, observations, steps, epsilon_init, n_samples=10000, n_samples_per_param=1, epsilon_percentile=10,
+               covFactor=2, full_output=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -385,9 +383,9 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
         """
         self.accepted_parameters_manager.broadcast(self.backend, observations)
         self.n_samples = n_samples
-        self.n_samples_per_param=n_samples_per_param
+        self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
@@ -416,11 +414,12 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
         self.logger.info("Starting PMC iterations")
         for aStep in range(steps):
             self.logger.debug("iteration {} of PMC algorithm".format(aStep))
-            if(aStep==0 and journal_file is not None):
+            if aStep == 0 and journal_file is not None:
                 accepted_parameters = journal.get_accepted_parameters(-1)
                 accepted_weights = journal.get_weights(-1)
 
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                                  accepted_weights=accepted_weights)
 
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
@@ -435,19 +434,19 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
                 # accepted_cov_mats = [covFactor * new_cov_mat for new_cov_mat in new_cov_mats]
                 accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
 
-            
             seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32)
             rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
             rng_pds = self.backend.parallelize(rng_arr)
 
             # 0: update remotely required variables
-            #print("INFO: Broadcasting parameters.")
+            # print("INFO: Broadcasting parameters.")
             self.logger.info("Broadcasting parameters")
             self.epsilon = epsilon_arr[aStep]
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters, accepted_weights, accepted_cov_mats)
+            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters, accepted_weights,
+                                                              accepted_cov_mats)
 
             # 1: calculate resample parameters
-            #print("INFO: Resampling parameters")
+            # print("INFO: Resampling parameters")
             self.logger.info("Resamping parameters")
 
             params_and_dists_and_counter_pds = self.backend.map(self._resample_parameter, rng_pds)
@@ -457,13 +456,13 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
             distances = np.array(distances)
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             # Compute epsilon for next step
             # print("INFO: Calculating acceptance threshold (epsilon).")
             self.logger.info("Calculating acceptances threshold")
             if aStep < steps - 1:
-                if epsilon_arr[aStep + 1] == None:
+                if epsilon_arr[aStep + 1] is None:
                     epsilon_arr[aStep + 1] = np.percentile(distances, epsilon_percentile)
                 else:
                     epsilon_arr[aStep + 1] = np.max(
@@ -480,7 +479,8 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
             new_weights = new_weights / sum_of_weights
 
             # The calculation of cov_mats needs the new weights and new parameters
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters = new_parameters, accepted_weights=new_weights)
+            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=new_parameters,
+                                                              accepted_weights=new_weights)
 
             # The parameters relevant to each kernel have to be used to calculate n_sample times. It is therefore more efficient to broadcast these parameters once,
             # instead of collecting them at each kernel in each step
@@ -494,7 +494,7 @@ def sample(self, observations, steps, epsilon_init, n_samples = 10000, n_samples
             self.logger.info("Calculating covariance matrix")
             new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
             # Since each entry of new_cov_mats is a numpy array, we can multiply like this
-            new_cov_mats = [covFactor*new_cov_mat for new_cov_mat in new_cov_mats]
+            new_cov_mats = [covFactor * new_cov_mat for new_cov_mat in new_cov_mats]
 
             # 4: Update the newly computed values
             accepted_parameters = new_parameters
@@ -535,7 +535,7 @@ def _resample_parameter(self, rng, npc=None):
             accepted parameter
         """
 
-        #print(npc.communicator())
+        # print(npc.communicator())
         rng.seed(rng.randint(np.iinfo(np.uint32).max, dtype=np.uint32))
 
         distance = self.distance.dist_max()
@@ -545,38 +545,37 @@ def _resample_parameter(self, rng, npc=None):
                              .format(float(self.epsilon), distance))
 
         theta = self.get_parameters()
-        counter=0
+        counter = 0
 
         while distance > self.epsilon:
-            if self.accepted_parameters_manager.accepted_parameters_bds == None:
+            if self.accepted_parameters_manager.accepted_parameters_bds is None:
                 self.sample_from_prior(rng=rng)
                 theta = self.get_parameters()
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-                counter+=1
+                counter += 1
 
             else:
-                index = rng.choice(self.n_samples, size=1, p=self.accepted_parameters_manager.accepted_weights_bds.value().reshape(-1))
+                index = rng.choice(self.n_samples, size=1,
+                                   p=self.accepted_parameters_manager.accepted_weights_bds.value().reshape(-1))
                 # truncate the normal to the bounds of parameter space of the model
                 # truncating the normal like this is fine: https://arxiv.org/pdf/0907.4010v1.pdf
                 while True:
                     perturbation_output = self.perturb(index[0], rng=rng)
-                    if(perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1])!=0):
+                    if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                         theta = perturbation_output[1]
                         break
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-                counter+=1
+                counter += 1
 
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
-            self.logger.debug("distance after {:4d} simulations: {:e}".format(
-                     counter, distance))
+            self.logger.debug("distance after {:4d} simulations: {:e}".format(counter, distance))
 
-        self.logger.debug(
-                "Needed {:4d} simulations to reach distance {:e} < epsilon = {:e}".
-                format(counter, distance, float(self.epsilon))
-                )
+        self.logger.debug("Needed {:4d} simulations to reach distance {:e} < epsilon = {:e}".format(counter, distance,
+                                                                                                    float(
+                                                                                                        self.epsilon)))
 
-        return (theta, distance, counter)
+        return theta, distance, counter
 
     def _calculate_weight(self, theta, npc=None):
         """
@@ -600,7 +599,8 @@ def _calculate_weight(self, theta, npc=None):
             prior_prob = self.pdf_of_prior(self.model, theta, 0)
 
             # Get the mapping of the models to be used by the kernels
-            mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(self.accepted_parameters_manager.model)
+            mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(
+                self.accepted_parameters_manager.model)
             pdf_values = np.array([self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
                                                    self.accepted_parameters_manager.accepted_parameters_bds.value()[i],
                                                    theta) for i in range(self.n_samples)])
@@ -619,6 +619,7 @@ def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
                 accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
         return accepted_cov_mats
 
+
 class PMC(BaseLikelihood, InferenceMethod):
     """
     Population Monte Carlo based inference scheme of Cappé et. al. [1].
@@ -661,13 +662,12 @@ class PMC(BaseLikelihood, InferenceMethod):
 
     backend = None
 
-
     def __init__(self, root_models, likfuns, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Product of likelihood functions using all the likelihoods for each individual models
         self.likfun = ProductCombination(root_models, likfuns)
 
-        if(kernel is None):
+        if kernel is None:
 
             mapping, garbage_index = self._get_mapping()
             models = []
@@ -686,8 +686,8 @@ def __init__(self, root_models, likfuns, backend, kernel=None, seed=None):
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 100, covFactors = None, iniPoints = None, full_output=0, journal_file = None):
+    def sample(self, observations, steps, n_samples=10000, n_samples_per_param=100, covFactors=None, iniPoints=None,
+               full_output=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -724,7 +724,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_lhd_func"] = type(self.likfun).__name__
@@ -746,7 +746,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
         # Initialize particles: When not supplied, randomly draw them from prior distribution
         # Weights of particles: Assign equal weights for each of the particles
-        if iniPoints == None:
+        if iniPoints is None:
             accepted_parameters = []
             for ind in range(0, n_samples):
                 self.sample_from_prior(rng=self.rng)
@@ -759,7 +759,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         if covFactors is None:
             covFactors = np.ones(shape=(len(self.kernel.kernels),))
 
-        self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+        self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                          accepted_weights=accepted_weights)
 
         # The parameters relevant to each kernel have to be used to calculate n_sample times. It is therefore more efficient
         # to broadcast these parameters once, instead of collecting them at each kernel in each step
@@ -783,11 +784,12 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         # main SMC algorithm
         self.logger.info("Starting pmc iterations")
         for aStep in range(steps):
-            if(aStep==0 and journal_file is not None):
+            if aStep == 0 and journal_file is not None:
                 accepted_parameters = journal.get_accepted_parameters(-1)
                 accepted_weights = journal.get_weights(-1)
 
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                                  accepted_weights=accepted_weights)
 
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
@@ -799,7 +801,6 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 # 3: calculate covariance
                 self.logger.info("Calculating covariance matrix")
 
-
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
                 # Since each entry of new_cov_mats is a numpy array, we can multiply like this
 
@@ -811,7 +812,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             # 0: update remotely required variables
             self.logger.info("Broadcasting parameters")
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
-                                                              accepted_weights=accepted_weights, accepted_cov_mats=accepted_cov_mats)
+                                                              accepted_weights=accepted_weights,
+                                                              accepted_cov_mats=accepted_cov_mats)
 
             # 1: Resample parameters
             self.logger.info("Resample parameters")
@@ -822,7 +824,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             for ind in range(0, self.n_samples):
                 while True:
                     perturbation_output = self.perturb(index[ind], rng=self.rng)
-                    if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1])!= 0:
+                    if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                         new_parameters.append(perturbation_output[1])
                         break
 
@@ -836,7 +838,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
             approx_likelihood_new_parameters_and_counter_pds = self.backend.map(self._approx_lik_calc, data_pds)
             self.logger.debug("collect approximate likelihood from pds")
-            approx_likelihood_new_parameters_and_counter = self.backend.collect(approx_likelihood_new_parameters_and_counter_pds)
+            approx_likelihood_new_parameters_and_counter = self.backend.collect(
+                approx_likelihood_new_parameters_and_counter_pds)
             approx_likelihood_new_parameters, counter = [list(t) for t in
                                                          zip(*approx_likelihood_new_parameters_and_counter)]
 
@@ -858,15 +861,16 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
             # self.logger.info("new_weights : ", new_weights, ", sum_of_weights : ", sum_of_weights)
             self.logger.info("sum_of_weights : {}".format(sum_of_weights))
-            accepted_parameters = new_parameters
+            accepted_parameters = new_parameters  # this is repeated uselessly below
 
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=new_weights)
+            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                              accepted_weights=new_weights)
 
             # 4: calculate covariance
             # The parameters relevant to each kernel have to be used to calculate n_sample times. It is therefore more efficient to broadcast these parameters once, instead of collecting them at each kernel in each step
             self.logger.info("Calculating covariance matrix")
-            kernel_parameters = []
-            kernel_parameters = [self.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models) for kernel in self.kernel.kernels]
+            kernel_parameters = [self.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models) for
+                                 kernel in self.kernel.kernels]
 
             self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
@@ -933,7 +937,7 @@ def _approx_lik_calc(self, data, npc=None):
 
         self.logger.debug("Prior pdf evaluated at theta is :" + str(pdf_at_theta))
 
-        return (total_pdf_at_theta, self.n_samples_per_param)
+        return total_pdf_at_theta, self.n_samples_per_param
 
     def _calculate_weight(self, theta, npc=None):
         """
@@ -1020,7 +1024,7 @@ def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         # We define the joint Linear combination distance using all the distances for each individual models
         self.distance = LinearCombination(root_models, distances)
 
-        if (kernel is None):
+        if kernel is None:
 
             mapping, garbage_index = self._get_mapping()
             models = []
@@ -1041,9 +1045,8 @@ def __init__(self, root_models, distances, backend, kernel=None, seed=None):
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_param = 1, beta = 2, delta = 0.2,
-               v = 0.3, ar_cutoff = 0.1, resample = None, n_update = None, full_output=0, journal_file = None):
+    def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_param=1, beta=2, delta=0.2,
+               v=0.3, ar_cutoff=0.1, resample=None, n_update=None, full_output=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -1090,7 +1093,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
@@ -1114,9 +1117,9 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
         all_distances = None
         accepted_cov_mat = None
 
-        if resample == None:
+        if resample is None:
             resample = n_samples
-        if n_update == None:
+        if n_update is None:
             n_update = n_samples
         sample_array = np.ones(shape=(steps,))
         sample_array[0] = n_samples
@@ -1131,19 +1134,20 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
 
         for aStep in range(0, steps):
             self.logger.debug("step {}".format(aStep))
-            if(aStep==0 and journal_file is not None):
-                accepted_parameters=journal.get_accepted_parameters(-1)
-                accepted_weights=journal.get_weights(-1)
+            if aStep == 0 and journal_file is not None:
+                accepted_parameters = journal.get_accepted_parameters(-1)
+                accepted_weights = journal.get_weights(-1)
 
-                #Broadcast Accepted parameters and Accedpted weights
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+                # Broadcast Accepted parameters and Accedpted weights
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                                  accepted_weights=accepted_weights)
 
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
                     kernel_parameters.append(
                         self.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models))
 
-                #Broadcast Accepted Kernel parameters
+                # Broadcast Accepted Kernel parameters
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
 
                 new_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
@@ -1173,16 +1177,15 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
             self.logger.debug("Map step of parallelism is finished")
             params_and_dists = self.backend.collect(params_and_dists_pds)
             self.logger.debug("Collect step of parallelism is finished")
-            new_parameters, new_distances, new_all_parameters, new_all_distances, index, acceptance, counter = [list(t) for t in
-                                                                                                       zip(
-                                                                                                           *params_and_dists)]
+            new_parameters, new_distances, new_all_parameters, new_all_distances, index, acceptance, counter = [
+                list(t) for t in zip(*params_and_dists)]
 
             # Keeping counter of number of simulations
             self.logger.debug("Counting number of simulations")
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
-            #new_parameters = np.array(new_parameters)
+            # new_parameters = np.array(new_parameters)
             new_distances = np.array(new_distances)
             new_all_distances = np.concatenate(new_all_distances)
             index = np.array(index)
@@ -1223,12 +1226,8 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 samples_until = samples_until + sample_array[aStep]
                 acceptance_rate = accept / samples_until
 
-                msg = ("updates= {:.2f}, epsilon= {}, u.mean={:e}, acceptance rate: {:.2f}"
-                        .format(
-                            np.sum(sample_array[1:aStep + 1]) / np.sum(sample_array[1:]) * 100,
-                            epsilon, U, acceptance_rate
-                            )
-                        )
+                msg = ("updates= {:.2f}, epsilon= {}, u.mean={:e}, acceptance rate: {:.2f}".format(
+                    np.sum(sample_array[1:aStep + 1]) / np.sum(sample_array[1:]) * 100, epsilon, U, acceptance_rate))
                 self.logger.info(msg)
                 if acceptance_rate < ar_cutoff:
                     broken_preemptively = True
@@ -1251,14 +1250,15 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
                 epsilon = self._schedule(U, v)
 
                 ## Print effective sampling size
-                self.logger.info('Resampling: Effective sampling size: '+str(1 / sum(pow(weight / sum(weight), 2))))
+                self.logger.info('Resampling: Effective sampling size: ' + str(1 / sum(pow(weight / sum(weight), 2))))
                 accept = 0
                 samples_until = 0
 
                 ## Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
                 # Broadcast Accepted parameters and add to journal
                 self.logger.info("Broadcast Accepted parameters and add to journal")
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights, accepted_parameters=accepted_parameters)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
+                                                                  accepted_parameters=accepted_parameters)
                 # Compute Accepetd Kernel parameters and broadcast them
                 self.logger.debug("Compute Accepetd Kernel parameters and broadcast them")
                 kernel_parameters = []
@@ -1273,7 +1273,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
-                if (full_output == 1 and aStep<= steps-1):
+                if full_output == 1 and aStep <= steps - 1:
                     ## Saving intermediate configuration to output journal.
                     self.logger.info('Saving after resampling')
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
@@ -1285,7 +1285,8 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
             else:
                 ## Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
                 # Broadcast Accepted parameters
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights= accepted_weights, accepted_parameters=accepted_parameters)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
+                                                                  accepted_parameters=accepted_parameters)
                 # Compute Accepetd Kernel parameters and broadcast them
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
@@ -1298,7 +1299,7 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
-                if (full_output == 1 and aStep <= steps-1):
+                if full_output == 1 and aStep <= steps - 1:
                     ## Saving intermediate configuration to output journal.
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                     journal.add_weights(copy.deepcopy(accepted_weights))
@@ -1309,11 +1310,12 @@ def sample(self, observations, steps, epsilon, n_samples = 10000, n_samples_per_
 
         # Add epsilon_arr, number of final steps and final output to the journal
         # print("INFO: Saving final configuration to output journal.")
-        if (full_output == 0) or (full_output ==1 and broken_preemptively and aStep<= steps-1):
+        if (full_output == 0) or (full_output == 1 and broken_preemptively and aStep <= steps - 1):
             journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
             journal.add_weights(copy.deepcopy(accepted_weights))
             journal.add_distances(copy.deepcopy(distances))
-            self.accepted_parameters_manager.update_broadcast(self.backend,accepted_parameters=accepted_parameters,accepted_weights=accepted_weights)
+            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                              accepted_weights=accepted_weights)
             names_and_parameters = self._get_names_and_parameters()
             journal.add_user_parameters(names_and_parameters)
             journal.number_of_simulations.append(self.simulation_counter)
@@ -1373,7 +1375,7 @@ def _average_redefined_distance(self, distance, epsilon):
         else:
             U = np.average(distance, weights=np.exp(-distance / epsilon))
 
-        return (U)
+        return U
 
     def _schedule(self, rho, v):
         if rho < 1e-100:
@@ -1382,13 +1384,14 @@ def _schedule(self, rho, v):
             fun = lambda epsilon: pow(epsilon, 2) + v * pow(epsilon, 3 / 2) - pow(rho, 2)
             epsilon = optimize.fsolve(fun, rho / 2)
 
-        return (epsilon)
+        return epsilon
 
     def _update_broadcasts(self, smooth_distances, all_distances):
         def destroy(bc):
             if bc != None:
                 bc.unpersist
                 # bc.destroy
+
         if not smooth_distances is None:
             self.smooth_distances_bds = self.backend.broadcast(smooth_distances)
         if not all_distances is None:
@@ -1410,10 +1413,10 @@ def _accept_parameter(self, data, npc=None):
         numpy.ndarray
             accepted parameter
         """
-        if(isinstance(data,np.ndarray)):
+        if isinstance(data, np.ndarray):
             data = data.tolist()
-        rng=data[0]
-        index=data[1]
+        rng = data[0]
+        index = data[1]
         rng.seed(rng.randint(np.iinfo(np.uint32).max, dtype=np.uint32))
 
         all_parameters = []
@@ -1422,7 +1425,7 @@ def _accept_parameter(self, data, npc=None):
 
         counter = 0
 
-        if self.accepted_parameters_manager.accepted_cov_mats_bds == None:
+        if self.accepted_parameters_manager.accepted_cov_mats_bds is None:
 
             while acceptance == 0:
                 self.sample_from_prior(rng=rng)
@@ -1431,7 +1434,7 @@ def _accept_parameter(self, data, npc=None):
                 t0 = time.time()
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
                 self.logger.debug("Simulation took " + str(time.time() - t0) + "sec")
-                counter+=1
+                counter += 1
                 distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
                 all_distances.append(distance)
                 acceptance = rng.binomial(1, np.exp(-distance / self.epsilon), 1)
@@ -1449,15 +1452,15 @@ def _accept_parameter(self, data, npc=None):
                     break
             t0 = time.time()
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            self.logger.debug("Simulation took "+ str(time.time()-t0)+"sec")
-            counter+=1
+            self.logger.debug("Simulation took " + str(time.time() - t0) + "sec")
+            counter += 1
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
             smooth_distance = self._smoother_distance([distance], self.all_distances_bds.value())
 
             ## Calculate acceptance probability:
             self.logger.debug("Calulate acceptance probability")
-            ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
-                self.accepted_parameters_manager.accepted_parameters_bds.value()[index])
+            ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(
+                self.model, self.accepted_parameters_manager.accepted_parameters_bds.value()[index])
             ratio_likelihood_prob = np.exp((self.smooth_distances_bds.value()[index] - smooth_distance) / self.epsilon)
             acceptance_prob = ratio_prior_prob * ratio_likelihood_prob
 
@@ -1467,7 +1470,7 @@ def _accept_parameter(self, data, npc=None):
             else:
                 distance = np.inf
 
-        return (new_theta, distance, all_parameters, all_distances, index, acceptance, counter)
+        return new_theta, distance, all_parameters, all_distances, index, acceptance, counter
 
     def _compute_accepted_cov_mats(self, beta, new_cov_mats):
         accepted_cov_mats = []
@@ -1480,8 +1483,6 @@ def _compute_accepted_cov_mats(self, beta, new_cov_mats):
         return accepted_cov_mats
 
 
-
-
 class ABCsubsim(BaseDiscrepancy, InferenceMethod):
     """This base class implements Approximate Bayesian Computation by subset simulation (ABCsubsim) algorithm of [1].
 
@@ -1514,7 +1515,7 @@ class ABCsubsim(BaseDiscrepancy, InferenceMethod):
 
     backend = None
 
-    def __init__(self, root_models, distances, backend, kernel=None,seed=None):
+    def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Linear combination distance using all the distances for each individual models
         self.distance = LinearCombination(root_models, distances)
@@ -1534,15 +1535,14 @@ def __init__(self, root_models, distances, backend, kernel=None,seed=None):
         self.anneal_parameter = None
         self.logger = logging.getLogger(__name__)
 
-
         # these are usually big tables, so we broadcast them to have them once
         # per executor instead of once per task
         self.accepted_parameters_manager = AcceptedParametersManager(self.model)
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1, chain_length = 10, ap_change_cutoff = 10, full_output=0, journal_file = None):
+    def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, chain_length=10, ap_change_cutoff=10,
+               full_output=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -1580,7 +1580,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
@@ -1600,10 +1600,9 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         anneal_parameter_old = 0
         temp_chain_length = 1
 
-
         for aStep in range(0, steps):
             self.logger.info("ABCsubsim step {}".format(aStep))
-            if aStep==0 and journal_file is not None:
+            if aStep == 0 and journal_file is not None:
                 accepted_parameters = journal.get_accepted_parameters(-1)
                 accepted_weights = journal.get_weights(-1)
                 accepted_cov_mats = journal.opt_values[-1]
@@ -1621,7 +1620,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             # 0: update remotely required variables
             self.logger.info("Broadcasting parameters")
 
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights = accepted_weights, accepted_parameters=accepted_parameters)
+            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
+                                                              accepted_parameters=accepted_parameters)
 
             # 1: Calculate  parameters
             # print("INFO: Initial accepted parameter parameters")
@@ -1633,7 +1633,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             new_parameters, new_distances, counter = [list(t) for t in zip(*params_and_dists)]
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             if aStep > 0:
                 accepted_parameters = []
@@ -1647,7 +1647,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.logger.debug("Sort and renumber samples.")
 
             accepted_params_and_dist = zip(distances, accepted_parameters)
-            accepted_params_and_dist = sorted(accepted_params_and_dist, key = lambda x: x[0])
+            accepted_params_and_dist = sorted(accepted_params_and_dist, key=lambda x: x[0])
             distances, accepted_parameters = [list(t) for t in zip(*accepted_params_and_dist)]
 
             # 3: Calculate and broadcast annealling parameters
@@ -1656,10 +1656,9 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             if aStep > 0:
                 anneal_parameter_old = anneal_parameter
             anneal_parameter = 0.5 * (
-            distances[int(n_samples / temp_chain_length)] + distances[int(n_samples / temp_chain_length) + 1])
+                    distances[int(n_samples / temp_chain_length)] + distances[int(n_samples / temp_chain_length) + 1])
             self.anneal_parameter = anneal_parameter
 
-
             # 4: Update proposal covariance matrix (Parallelized)
             self.logger.debug("Update proposal covariance matrix (Parallelized).")
             if aStep == 0:
@@ -1672,7 +1671,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 self.accepted_parameters_manager.update_kernel_values(self.backend, kernel_parameters=kernel_parameters)
                 accepted_cov_mats = self.kernel.calculate_cov(self.accepted_parameters_manager)
             else:
-                accepted_cov_mats = pow(2,1)*accepted_cov_mats
+                accepted_cov_mats = pow(2, 1) * accepted_cov_mats
 
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
@@ -1689,7 +1688,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             cov_mats, T, accept_index, counter = [list(t) for t in zip(*cov_mats_index)]
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             for ind in range(10):
                 if accept_index[ind] == 1:
@@ -1712,7 +1711,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 journal.number_of_simulations.append(self.simulation_counter)
 
             # Show progress
-            anneal_parameter_change_percentage = 100 * abs(anneal_parameter_old - anneal_parameter) / abs(anneal_parameter)
+            anneal_parameter_change_percentage = 100 * abs(anneal_parameter_old - anneal_parameter) / abs(
+                anneal_parameter)
             msg = ("step: {}, annealing parameter: {:.4f}, change(%) in annealing parameter: {:.1f}"
                    .format(aStep, anneal_parameter, anneal_parameter_change_percentage))
             self.logger.info(msg)
@@ -1768,10 +1768,10 @@ def _accept_parameter(self, rng_and_index, npc=None):
 
         counter = 0
 
-        if self.accepted_parameters_manager.accepted_parameters_bds == None:
+        if self.accepted_parameters_manager.accepted_parameters_bds is None:
             self.sample_from_prior(rng=rng)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
             result_theta += self.get_parameters()
             result_distance.append(distance)
@@ -1779,26 +1779,29 @@ def _accept_parameter(self, rng_and_index, npc=None):
             theta = self.accepted_parameters_manager.accepted_parameters_bds.value()[index]
             self.set_parameters(theta)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
             result_theta.append(theta)
             result_distance.append(distance)
             for ind in range(0, self.chain_length - 1):
                 while True:
                     perturbation_output = self.perturb(index, rng=rng)
-                    if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1])!= 0:
+                    if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                         break
-                y_sim = self.simulate(self.n_samples_per_param, rng=rng,npc=npc)
-                counter+=1
+                y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
+                counter += 1
                 new_distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
                 ## Calculate acceptance probability:
-                ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model, theta)
-                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, perturbation_output[1], theta)
-                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta, perturbation_output[1])
+                ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
+                                                                                                             theta)
+                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   perturbation_output[1], theta)
+                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta,
+                                                     perturbation_output[1])
                 ratio_likelihood_prob = kernel_numerator / kernel_denominator
                 acceptance_prob = min(1, ratio_prior_prob * ratio_likelihood_prob) * (
-                new_distance < self.anneal_parameter)
+                        new_distance < self.anneal_parameter)
 
                 ## If accepted
                 if rng.binomial(1, acceptance_prob) == 1:
@@ -1833,7 +1836,8 @@ def _update_cov_mat(self, rng_t, npc=None):
 
         acceptance = 0
 
-        accepted_cov_mats_transformed = [cov_mat*pow(2.0, -2.0 * t) for cov_mat in self.accepted_parameters_manager.accepted_cov_mats_bds.value()]
+        accepted_cov_mats_transformed = [cov_mat * pow(2.0, -2.0 * t) for cov_mat in
+                                         self.accepted_parameters_manager.accepted_cov_mats_bds.value()]
 
         theta = self.accepted_parameters_manager.accepted_parameters_bds.value()[0]
 
@@ -1849,12 +1853,13 @@ def _update_cov_mat(self, rng_t, npc=None):
                 if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                     break
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
             new_distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
             self.logger.debug("Calculate acceptance probability.")
             ## Calculate acceptance probability:
-            ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model, theta)
+            ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
+                                                                                                         theta)
             kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
                                                perturbation_output[1], theta)
             kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta,
@@ -1867,9 +1872,9 @@ def _update_cov_mat(self, rng_t, npc=None):
 
         self.logger.debug("Return accepted parameters.")
         if acceptance / 10 <= 0.5 and acceptance / 10 >= 0.3:
-            return (accepted_cov_mats_transformed, t, 1, counter)
+            return accepted_cov_mats_transformed, t, 1, counter
         else:
-            return (accepted_cov_mats_transformed, t, 0, counter)
+            return accepted_cov_mats_transformed, t, 0, counter
 
 
 class RSMCABC(BaseDiscrepancy, InferenceMethod):
@@ -1908,7 +1913,6 @@ class RSMCABC(BaseDiscrepancy, InferenceMethod):
 
     backend = None
 
-
     def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Linear combination distance using all the distances for each individual models
@@ -1937,9 +1941,8 @@ def __init__(self, root_models, distances, backend, kernel=None, seed=None):
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1, alpha = 0.1, epsilon_init = 100,
-               epsilon_final = 0.1, const = 0.01, covFactor = 2.0, full_output=0, journal_file = None):
+    def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, alpha=0.1, epsilon_init=100,
+               epsilon_final=0.1, const=0.01, covFactor=2.0, full_output=0, journal_file=None):
         """
         Samples from the posterior distribution of the model parameter given the observed
         data observations.
@@ -1984,7 +1987,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
@@ -2004,10 +2007,11 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.logger.info("RSMCABC iteration {}".format(aStep))
 
             if aStep == 0 and journal_file is not None:
-                accepted_parameters=journal.get_accepted_parameters(-1)
+                accepted_parameters = journal.get_accepted_parameters(-1)
                 accepted_weights = journal.get_weights(-1)
 
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights= accepted_weights, accepted_parameters=accepted_parameters)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
+                                                                  accepted_parameters=accepted_parameters)
 
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
@@ -2031,8 +2035,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 # Compute epsilon
                 epsilon = [epsilon_init]
                 R = int(1)
-                if(journal_file is None):
-                    accepted_cov_mats=None
+                if journal_file is None:
+                    accepted_cov_mats = None
             else:
                 # Compute epsilon
                 epsilon.append(accepted_dist[-1])
@@ -2078,7 +2082,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             new_index = np.array(new_index)
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             # 1: Update all parameters, compute acceptance probability, compute epsilon
             self.logger.info("Append updated new parameters.")
@@ -2096,7 +2100,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(accepted_dist))
                 journal.add_weights(accepted_weights)
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights, accepted_parameters=accepted_parameters)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
+                                                                  accepted_parameters=accepted_parameters)
                 names_and_parameters = self._get_names_and_parameters()
                 journal.add_user_parameters(names_and_parameters)
                 journal.number_of_simulations.append(self.simulation_counter)
@@ -2112,7 +2117,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.logger.info("Order accepted parameters and distances")
             n_replenish = round(n_samples * alpha)
             accepted_params_and_dist = zip(accepted_dist, accepted_parameters)
-            accepted_params_and_dist = sorted(accepted_params_and_dist, key = lambda x: x[0])
+            accepted_params_and_dist = sorted(accepted_params_and_dist, key=lambda x: x[0])
             accepted_dist, accepted_parameters = [list(t) for t in zip(*accepted_params_and_dist)]
 
             self.logger.info("Throw away N_alpha particles with largest dist")
@@ -2128,7 +2133,6 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
                                                               accepted_parameters=accepted_parameters)
 
-
         # Add epsilon_arr to the journal
         journal.configuration["epsilon_arr"] = epsilon
 
@@ -2168,11 +2172,11 @@ def _accept_parameter(self, rng, npc=None):
 
         counter = 0
 
-        if self.accepted_parameters_manager.accepted_parameters_bds == None:
+        if self.accepted_parameters_manager.accepted_parameters_bds is None:
             while distance > self.epsilon[-1]:
                 self.sample_from_prior(rng=rng)
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-                counter+=1
+                counter += 1
                 distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
             index_accept = 1
@@ -2186,11 +2190,14 @@ def _accept_parameter(self, rng, npc=None):
                     if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                         break
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-                counter+=1
+                counter += 1
                 distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
-                ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model, theta)
-                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, perturbation_output[1], theta)
-                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta, perturbation_output[1])
+                ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
+                                                                                                             theta)
+                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   perturbation_output[1], theta)
+                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta,
+                                                     perturbation_output[1])
                 ratio_kernel_prob = kernel_numerator / kernel_denominator
                 probability_acceptance = min(1, ratio_prior_prob * ratio_kernel_prob)
                 if distance < self.epsilon[-1] and rng.binomial(1, probability_acceptance) == 1:
@@ -2199,7 +2206,7 @@ def _accept_parameter(self, rng, npc=None):
                     self.set_parameters(theta)
                     distance = self.accepted_dist_bds.value()[index[0]]
 
-        return (self.get_parameters(self.model), distance, index_accept, counter)
+        return self.get_parameters(self.model), distance, index_accept, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
@@ -2212,6 +2219,7 @@ def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
                 accepted_cov_mats.append((covFactor * new_cov_mat + 0.0001 * new_cov_mat).reshape(1, 1))
         return accepted_cov_mats
 
+
 class APMCABC(BaseDiscrepancy, InferenceMethod):
     """This base class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
     M. Lenormand et al. [1].
@@ -2248,7 +2256,7 @@ class APMCABC(BaseDiscrepancy, InferenceMethod):
 
     backend = None
 
-    def __init__(self,  root_models, distances, backend, kernel=None, seed=None):
+    def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Linear combination distance using all the distances for each individual models
         self.distance = LinearCombination(root_models, distances)
@@ -2265,7 +2273,7 @@ def __init__(self,  root_models, distances, backend, kernel=None, seed=None):
         self.backend = backend
         self.logger = logging.getLogger(__name__)
 
-        self.epsilon= None
+        self.epsilon = None
         self.rng = np.random.RandomState(seed)
 
         # these are usually big tables, so we broadcast them to have them once
@@ -2275,8 +2283,8 @@ def __init__(self,  root_models, distances, backend, kernel=None, seed=None):
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1, alpha = 0.1, acceptance_cutoff = 0.03, covFactor = 2.0, full_output=0, journal_file = None):
+    def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, alpha=0.1, acceptance_cutoff=0.03,
+               covFactor=2.0, full_output=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -2315,7 +2323,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
@@ -2337,11 +2345,12 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         # print("INFO: Starting APMCABC iterations.")
         for aStep in range(steps):
             self.logger.info("APMCABC iteration {}".format(aStep))
-            if(aStep==0 and journal_file is not None):
-                accepted_parameters=journal.get_accepted_parameters(-1)
-                accepted_weights=journal.get_weights(-1)
+            if aStep == 0 and journal_file is not None:
+                accepted_parameters = journal.get_accepted_parameters(-1)
+                accepted_weights = journal.get_weights(-1)
 
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                                  accepted_weights=accepted_weights)
 
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
@@ -2355,10 +2364,11 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 accepted_cov_mats = self._compute_accepted_cov_mats(covFactor, accepted_cov_mats)
                 # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
 
-                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights)
+                self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
+                                                                  accepted_weights=accepted_weights)
 
-                alpha_accepted_parameters=accepted_parameters
-                alpha_accepted_weights=accepted_weights
+                alpha_accepted_parameters = accepted_parameters
+                alpha_accepted_weights = accepted_weights
 
             # 0: Drawing new new/perturbed samples using prior or MCMC Kernel
             if aStep > 0:
@@ -2372,7 +2382,10 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
             # update remotely required variables
             self.logger.info("Broadcasting parameters")
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=alpha_accepted_parameters, accepted_weights=alpha_accepted_weights, accepted_cov_mats=accepted_cov_mats)
+            self.accepted_parameters_manager.update_broadcast(self.backend,
+                                                              accepted_parameters=alpha_accepted_parameters,
+                                                              accepted_weights=alpha_accepted_weights,
+                                                              accepted_cov_mats=accepted_cov_mats)
             self._update_broadcasts(alpha_accepted_dist)
 
             # calculate resample parameters
@@ -2385,7 +2398,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             new_weights = np.array(new_weights).reshape(n_additional_samples, 1)
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             # 1: Update all parameters, compute acceptance probability, compute epsilon
             if len(new_weights) == n_samples:
@@ -2413,7 +2426,9 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
             # 3: calculate covariance
             self.logger.info("Calculating covariance matrix")
-            self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=alpha_accepted_parameters, accepted_weights=alpha_accepted_weights)
+            self.accepted_parameters_manager.update_broadcast(self.backend,
+                                                              accepted_parameters=alpha_accepted_parameters,
+                                                              accepted_weights=alpha_accepted_weights)
 
             kernel_parameters = []
             for kernel in self.kernel.kernels:
@@ -2479,10 +2494,10 @@ def _accept_parameter(self, rng, npc=None):
 
         counter = 0
 
-        if self.accepted_parameters_manager.accepted_parameters_bds == None:
+        if self.accepted_parameters_manager.accepted_parameters_bds is None:
             self.sample_from_prior(rng=rng)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
             weight = 1.0
@@ -2497,18 +2512,19 @@ def _accept_parameter(self, rng, npc=None):
                     break
 
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
             prior_prob = self.pdf_of_prior(self.model, perturbation_output[1])
             denominator = 0.0
             for i in range(len(self.accepted_parameters_manager.accepted_weights_bds.value())):
                 pdf_value = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
-                                            self.accepted_parameters_manager.accepted_parameters_bds.value()[i], perturbation_output[1])
+                                            self.accepted_parameters_manager.accepted_parameters_bds.value()[i],
+                                            perturbation_output[1])
                 denominator += self.accepted_parameters_manager.accepted_weights_bds.value()[i, 0] * pdf_value
             weight = 1.0 * prior_prob / denominator
 
-        return (self.get_parameters(self.model), distance, weight, counter)
+        return self.get_parameters(self.model), distance, weight, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
@@ -2556,12 +2572,12 @@ class SMCABC(BaseDiscrepancy, InferenceMethod):
 
     backend = None
 
-    def __init__(self, root_models, distances, backend, kernel = None, seed=None):
+    def __init__(self, root_models, distances, backend, kernel=None, seed=None):
         self.model = root_models
         # We define the joint Linear combination distance using all the distances for each individual models
         self.distance = LinearCombination(root_models, distances)
 
-        if (kernel is None):
+        if kernel is None:
 
             mapping, garbage_index = self._get_mapping()
             models = []
@@ -2583,9 +2599,8 @@ def __init__(self, root_models, distances, backend, kernel = None, seed=None):
 
         self.simulation_counter = 0
 
-
-    def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1, epsilon_final = 0.1, alpha = 0.95,
-               covFactor = 2, resample = None, full_output=0, which_mcmc_kernel = 0, journal_file=None):
+    def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, epsilon_final=0.1, alpha=0.95,
+               covFactor=2, resample=None, full_output=0, which_mcmc_kernel=0, journal_file=None):
         """Samples from the posterior distribution of the model parameter given the observed
         data observations.
 
@@ -2627,13 +2642,14 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         self.n_samples = n_samples
         self.n_samples_per_param = n_samples_per_param
 
-        if(journal_file is None):
+        if journal_file is None:
             journal = Journal(full_output)
             journal.configuration["type_model"] = [type(model).__name__ for model in self.model]
             journal.configuration["type_dist_func"] = type(self.distance).__name__
             journal.configuration["n_samples"] = self.n_samples
             journal.configuration["n_samples_per_param"] = self.n_samples_per_param
             journal.configuration["steps"] = steps
+            # maybe add which kernel I am using?
         else:
             journal = Journal.fromFile(journal_file)
 
@@ -2642,8 +2658,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         accepted_cov_mats = None
         accepted_y_sim = None
 
-        # Define the resmaple parameter
-        if resample == None:
+        # Define the resample parameter
+        if resample is None:
             resample = n_samples * 0.5
 
         # Define epsilon_init
@@ -2653,9 +2669,9 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
         for aStep in range(0, steps):
             self.logger.info("SMCABC iteration {}".format(aStep))
 
-            if(aStep==0 and journal_file is not None):
-                accepted_parameters=journal.get_accepted_parameters(-1)
-                accepted_weights=journal.get_weights(-1)
+            if aStep == 0 and journal_file is not None:
+                accepted_parameters = journal.get_accepted_parameters(-1)
+                accepted_weights = journal.get_weights(-1)
                 accepted_y_sim = journal.opt_values[-1]
 
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
@@ -2693,14 +2709,15 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             # 1: calculate weights for new parameters
             self.logger.info("Calculating weights")
             if accepted_y_sim != None:
-                new_weights = np.zeros(shape=(n_samples), )
+                new_weights = np.zeros(shape=n_samples, )
                 for ind1 in range(n_samples):
                     numerator = 0.0
                     denominator = 0.0
                     for ind2 in range(n_samples_per_param):
-                        numerator += (self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon[-1])
+                        numerator += (self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon[
+                            -1])
                         denominator += (
-                        self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon[-2])
+                                self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon[-2])
                     if denominator != 0.0:
                         new_weights[ind1] = accepted_weights[ind1] * (numerator / denominator)
                     else:
@@ -2708,7 +2725,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
 
                 new_weights = new_weights / sum(new_weights)
             else:
-                new_weights = np.ones(shape=(n_samples), ) * (1.0 / n_samples)
+                new_weights = np.ones(shape=n_samples, ) * (1.0 / n_samples)
 
             # 2: Resample
             if accepted_y_sim != None and pow(sum(pow(new_weights, 2)), -1) < resample:
@@ -2718,15 +2735,16 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
                 # accepted_parameters is a list. Then the indexing here does not work:
                 # accepted_parameters = accepted_parameters[index_resampled]
                 # do instead:
-                accepted_parameters = [accepted_parameters[i] for i in index_resampled]  # why don't we use arrays however?
-                new_weights = np.ones(shape=(n_samples), ) * (1.0 / n_samples)
+                accepted_parameters = [accepted_parameters[i] for i in
+                                       index_resampled]  # why don't we use arrays however?
+                new_weights = np.ones(shape=n_samples, ) * (1.0 / n_samples)
 
             # Update the weights
             accepted_weights = new_weights.reshape(len(new_weights), 1)
 
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                               accepted_weights=accepted_weights)
-            if(accepted_y_sim is not None):
+            if accepted_y_sim is not None:
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
                     kernel_parameters.append(
@@ -2750,7 +2768,8 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             self.epsilon = epsilon
 
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
-                                                              accepted_weights=accepted_weights, accepted_cov_mats=accepted_cov_mats)
+                                                              accepted_weights=accepted_weights,
+                                                              accepted_cov_mats=accepted_cov_mats)
             self._update_broadcasts(accepted_y_sim)
 
             # calculate resample parameters
@@ -2764,7 +2783,7 @@ def sample(self, observations, steps, n_samples = 10000, n_samples_per_param = 1
             distances = np.array(distances)
 
             for count in counter:
-                self.simulation_counter+=count
+                self.simulation_counter += count
 
             # Update the parameters
             accepted_parameters = new_parameters
@@ -2815,15 +2834,15 @@ def _compute_epsilon(self, epsilon_new, epsilon, observations, accepted_y_sim, a
         """
 
         RHS = alpha * pow(sum(pow(accepted_weights, 2)), -1)
-        LHS = np.zeros(shape=(n_samples), )
+        LHS = np.zeros(shape=n_samples, )
         for ind1 in range(n_samples):
             numerator = 0.0
             denominator = 0.0
             for ind2 in range(n_samples_per_param):
                 numerator += (self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon_new)
                 denominator += (self.distance.distance(observations, [[accepted_y_sim[ind1][0][ind2]]]) < epsilon[-1])
-            if(denominator==0):
-                LHS[ind1]=0
+            if denominator == 0:
+                LHS[ind1] = 0
             else:
                 LHS[ind1] = accepted_weights[ind1] * (numerator / denominator)
         if sum(LHS) == 0:
@@ -2832,8 +2851,7 @@ def _compute_epsilon(self, epsilon_new, epsilon, observations, accepted_y_sim, a
             LHS = LHS / sum(LHS)
             LHS = pow(sum(pow(LHS, 2)), -1)
             result = RHS - LHS
-        return (result)
-
+        return result
 
     def _bisection(self, func, low, high, tol):
         # cache computed values, as we call func below
@@ -2858,6 +2876,7 @@ def destroy(bc):
             if bc != None:
                 bc.unpersist
                 # bc.destroy
+
         if not accepted_y_sim is None:
             self.accepted_y_sim_bds = self.backend.broadcast(accepted_y_sim)
 
@@ -2888,12 +2907,12 @@ def _accept_parameter(self, rng_and_index, npc=None):
         mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(
             self.accepted_parameters_manager.model)
 
-        counter=0
+        counter = 0
         # print("on seed " + str(seed) + " distance: " + str(distance) + " epsilon: " + str(self.epsilon))
         if self.accepted_parameters_manager.accepted_parameters_bds is None:
             self.sample_from_prior(rng=rng)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
         else:
             if self.accepted_parameters_manager.accepted_weights_bds.value()[index] > 0:
                 theta = self.accepted_parameters_manager.accepted_parameters_bds.value()[index]
@@ -2902,7 +2921,7 @@ def _accept_parameter(self, rng_and_index, npc=None):
                     if perturbation_output[0] and self.pdf_of_prior(self.model, perturbation_output[1]) != 0:
                         break
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-                counter+=1
+                counter += 1
                 y_sim_old = self.accepted_y_sim_bds.value()[index]
                 ## Calculate acceptance probability:
                 numerator = 0.0
@@ -2919,8 +2938,10 @@ def _accept_parameter(self, rng_and_index, npc=None):
 
                 ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
                                                                                                              theta)
-                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, perturbation_output[1], theta)
-                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta, perturbation_output[1])
+                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   perturbation_output[1], theta)
+                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta,
+                                                     perturbation_output[1])
                 ratio_likelihood_prob = kernel_numerator / kernel_denominator
 
                 acceptance_prob = min(1, ratio_data_epsilon * ratio_prior_prob * ratio_likelihood_prob)
@@ -2933,7 +2954,7 @@ def _accept_parameter(self, rng_and_index, npc=None):
                 self.set_parameters(self.accepted_parameters_manager.accepted_parameters_bds.value()[index])
                 y_sim = self.accepted_y_sim_bds.value()[index]
         distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
-        return (self.get_parameters(), y_sim, distance, counter)
+        return self.get_parameters(), y_sim, distance, counter
 
     def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
         """
@@ -2959,14 +2980,15 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
 
         # Set value of r for r-hit kernel
         r = 3
-        mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(self.accepted_parameters_manager.model)
+        mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(
+            self.accepted_parameters_manager.model)
 
-        counter=0
+        counter = 0
         # print("on seed " + str(seed) + " distance: " + str(distance) + " epsilon: " + str(self.epsilon))
         if self.accepted_parameters_manager.accepted_parameters_bds is None:
             self.sample_from_prior(rng=rng)
             y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
-            counter+=1
+            counter += 1
         else:
             if self.accepted_parameters_manager.accepted_weights_bds.value()[index] > 0:
                 theta = self.accepted_parameters_manager.accepted_parameters_bds.value()[index]
@@ -2974,7 +2996,7 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
                 # Sample from theta until we get 'r-1' y_sim inside the epsilon ball
                 self.set_parameters(theta)
                 accept_old_arr, y_sim_old_arr, N_old = [], [], 0
-                while sum(accept_old_arr) < r-1:
+                while sum(accept_old_arr) < r - 1:
                     y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
                     y_sim_old_arr.append(y_sim)
                     if self.distance.distance(self.accepted_parameters_manager.observations_bds.value(),
@@ -2998,14 +3020,16 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
                     counter += 1
                     N += 1
 
-                #Calculate acceptance probability
+                # Calculate acceptance probability
                 ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
                                                                                                              theta)
-                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, perturbation_output[1], theta)
-                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta, perturbation_output[1])
+                kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   perturbation_output[1], theta)
+                kernel_denominator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager, theta,
+                                                     perturbation_output[1])
                 ratio_likelihood_prob = kernel_numerator / kernel_denominator
 
-                acceptance_prob = min(1, (N_old/(N-1)) * ratio_prior_prob * ratio_likelihood_prob)
+                acceptance_prob = min(1, (N_old / (N - 1)) * ratio_prior_prob * ratio_likelihood_prob)
 
                 if rng.binomial(1, acceptance_prob) == 1:
                     self.set_parameters(perturbation_output[1])
@@ -3019,7 +3043,7 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
                 self.set_parameters(self.accepted_parameters_manager.accepted_parameters_bds.value()[index])
                 y_sim = self.accepted_y_sim_bds.value()[index]
         distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
-        return (self.get_parameters(), y_sim, distance, counter)
+        return self.get_parameters(), y_sim, distance, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
diff --git a/abcpy/jointapprox_lhd.py b/abcpy/jointapprox_lhd.py
index 502b000a..23e96821 100644
--- a/abcpy/jointapprox_lhd.py
+++ b/abcpy/jointapprox_lhd.py
@@ -1,11 +1,11 @@
 from abc import ABCMeta, abstractmethod
 
 
-class JointApprox_likelihood(metaclass = ABCMeta):
+class JointApprox_likelihood(metaclass=ABCMeta):
     """This abstract base class defines how the combination of distances computed on the observed and
     simulated datasets corresponding to different root models should be implemented.
     """
-    
+
     @abstractmethod
     def __init__(self, models, approx_lhds):
         """The constructor of a sub-class must accept non-optional models and corresponding distances
@@ -20,7 +20,7 @@ def __init__(self, models, approx_lhds):
             in the same order as corresponding root models for which it would be used to compute the
             approximate likelihood
         """
-        
+
         raise NotImplementedError
 
     @abstractmethod
@@ -48,22 +48,22 @@ def likelihood(self, d1, d2):
 
         raise NotImplemented
 
+
 class ProductCombination(JointApprox_likelihood):
     """
     This class implements the product combination of different approximate likelihoods computed on different datasets corresponding to
     different root models
 
     """
-    
+
     def __init__(self, models, approx_lhds):
 
-        if len(models)!=len(approx_lhds):
+        if len(models) != len(approx_lhds):
             raise ValueError('Number of root models and Number of assigned approximate likelihoods are not same')
 
         self.models = models
         self.approx_lhds = approx_lhds
 
-
     def likelihood(self, d1, d2):
         """Combine the distances between different datasets.
 
@@ -76,7 +76,7 @@ def likelihood(self, d1, d2):
             raise TypeError('Data is not of allowed types')
         if not isinstance(d2, list):
             raise TypeError('Data is not of allowed types')
-        if len(d1)!=len(d2):
+        if len(d1) != len(d2):
             raise ValueError('Both the datasets should contain dataset for each of the root models')
 
         combined_likelihood = 1.0
diff --git a/abcpy/jointdistances.py b/abcpy/jointdistances.py
index e4ed21ce..6490fff8 100644
--- a/abcpy/jointdistances.py
+++ b/abcpy/jointdistances.py
@@ -2,11 +2,12 @@
 
 import numpy as np
 
-class JointDistance(metaclass = ABCMeta):
+
+class JointDistance(metaclass=ABCMeta):
     """This abstract base class defines how the combination of distances computed on the observed and
     simulated datasets corresponding to different root models should be implemented.
     """
-    
+
     @abstractmethod
     def __init__(self, models, distances):
         """The constructor of a sub-class must accept non-optional models and corresponding distances
@@ -21,10 +22,9 @@ def __init__(self, models, distances):
             in the same order as corresponding root models for which it would be used to compute the
             distance
         """
-        
+
         raise NotImplementedError
 
-    
     @abstractmethod
     def distance(d1, d2):
         """To be overwritten by any sub-class: should calculate the distance between two
@@ -47,10 +47,9 @@ def distance(d1, d2):
         numpy.ndarray
             The distance between the two input data sets.
         """
-                
+
         raise NotImplementedError
 
-    
     @abstractmethod
     def dist_max(self):
         """To be overwritten by sub-class: should return maximum possible value of the
@@ -65,9 +64,10 @@ def dist_max(self):
         numpy.float
             The maximal possible value of the desired distance function.
         """
-        
+
         raise NotImplementedError
 
+
 class LinearCombination(JointDistance):
     """
     This class implements the linear combination of different distances computed on different datasets corresponding to
@@ -75,7 +75,7 @@ class LinearCombination(JointDistance):
 
     The maximum value of the distance is linear combination of the maximum value of the different distances it combines.
     """
-    
+
     def __init__(self, models, distances, weights=None):
         """Combine the distances between different datasets.
 
@@ -85,23 +85,22 @@ def __init__(self, models, distances, weights=None):
             A list, containing the weights (for linear combination) corresponding to each of the distances. Should be
             the same length of models. The default value if None, for which we assign equal weights to all distances
         """
-        if len(models)!=len(distances):
+        if len(models) != len(distances):
             raise ValueError('Number of root models and Number of assigned distances are not same')
 
         if weights is None:
             self.weights = weights
-            self.weights = np.ones(shape=(len(distances,)))/len(distances)
+            self.weights = np.ones(shape=(len(distances, ))) / len(distances)
         else:
             if len(distances) != len(weights):
                 raise ValueError('Number of distances and Number of weights are not same')
             else:
                 weights = np.array(weights)
-                self.weights = np.array(weights/sum(weights)).reshape(-1,)
+                self.weights = np.array(weights / sum(weights)).reshape(-1, )
 
         self.models = models
         self.distances = distances
 
-
     def distance(self, d1, d2):
         """Combine the distances between different datasets.
 
@@ -114,18 +113,17 @@ def distance(self, d1, d2):
             raise TypeError('Data is not of allowed types')
         if not isinstance(d2, list):
             raise TypeError('Data is not of allowed types')
-        if len(d1)!=len(d2):
+        if len(d1) != len(d2):
             raise ValueError('Both the datasets should contain dataset for each of the root models')
 
         combined_distance = 0.0
         for ind in range(len(self.distances)):
-            combined_distance += self.weights[ind]*self.distances[ind].distance(d1[ind], d2[ind])
+            combined_distance += self.weights[ind] * self.distances[ind].distance(d1[ind], d2[ind])
 
         return combined_distance
 
-    
     def dist_max(self):
         combined_distance_max = 0.0
         for ind in range(len(self.distances)):
-            combined_distance_max += self.weights[ind]*self.distances[ind].dist_max()
+            combined_distance_max += self.weights[ind] * self.distances[ind].dist_max()
         return combined_distance_max
diff --git a/abcpy/modelselections.py b/abcpy/modelselections.py
index c2c7f1e5..3f3bac5b 100644
--- a/abcpy/modelselections.py
+++ b/abcpy/modelselections.py
@@ -1,19 +1,20 @@
 from abc import ABCMeta, abstractmethod
+
 import numpy as np
 from sklearn import ensemble
-from abcpy.graphtools import *
 
+from abcpy.graphtools import *
 
 
-class ModelSelections(metaclass = ABCMeta):
+class ModelSelections(metaclass=ABCMeta):
     """This abstract base class defines a model selection rule of how to choose a model from a set of models
     given an observation. 
  
             
     """
-    
+
     @abstractmethod
-    def __init__(self, model_array, statistics_calc, backend, seed = None):
+    def __init__(self, model_array, statistics_calc, backend, seed=None):
         """Constructor that must be overwritten by the sub-class.
 
         The constructor of a sub-class must accept an array of models to choose the model 
@@ -31,13 +32,12 @@ def __init__(self, model_array, statistics_calc, backend, seed = None):
             Backend object that conforms to the Backend class.
         seed: integer, optional
             Optional initial seed for the random number generator. The default value is generated randomly.    
-        """   
+        """
         self.model_array = model_array
         self.statistics_calc = statistics_calc
         self.backend = backend
         self.rng = np.random.RandomState(seed)
         self.reference_table_calculated = None
-        
 
         raise NotImplementedError
 
@@ -45,10 +45,9 @@ def __getstate__(self):
         state = self.__dict__.copy()
         del state['backend']
         return state
-        
-        
+
     @abstractmethod
-    def select_model(self, observations, n_samples = 1000, n_samples_per_param = 100):
+    def select_model(self, observations, n_samples=1000, n_samples_per_param=100):
         """To be overwritten by any sub-class: returns a model selected by the modelselection
         procedure most suitable to the obersved data set observations. Further two optional integer arguments n_samples
         and n_samples_per_param is supplied denoting the number of samples in the refernce table and the data points in
@@ -68,7 +67,7 @@ def select_model(self, observations, n_samples = 1000, n_samples_per_param = 100
             A model which are of type abcpy.probabilisticmodels
             
         """
-        
+
         raise NotImplementedError
 
     @abstractmethod
@@ -85,9 +84,10 @@ def posterior_probability(self, observations):
         np.ndarray
             A vector containing the approximate posterior probability of the model chosen.                
         """
-        
+
         raise NotImplementedError
-        
+
+
 class RandomForest(ModelSelections, GraphTools):
     """
     This class implements the model selection procedure based on the Random Forest ensemble learner
@@ -96,7 +96,8 @@ class RandomForest(ModelSelections, GraphTools):
     [1] Pudlo, P., Marin, J.-M., Estoup, A., Cornuet, J.-M., Gautier, M. and Robert, C.
     (2016). Reliable ABC model choice via random forests. Bioinformatics, 32 859–866.
     """
-    def __init__(self, model_array, statistics_calc, backend, N_tree = 100, n_try_fraction = 0.5, seed = None):
+
+    def __init__(self, model_array, statistics_calc, backend, N_tree=100, n_try_fraction=0.5, seed=None):
         """        
         Parameters
         ----------
@@ -107,7 +108,7 @@ def __init__(self, model_array, statistics_calc, backend, N_tree = 100, n_try_fr
             the number of covariates randomly sampled at each node by the randomised CART.
             The default value is 0.5.           
         """
-        
+
         self.model_array = model_array
         self.statistics_calc = statistics_calc
         self.backend = backend
@@ -122,7 +123,7 @@ def __init__(self, model_array, statistics_calc, backend, N_tree = 100, n_try_fr
 
         self.observations_bds = None
 
-    def select_model(self, observations, n_samples = 1000, n_samples_per_param = 1):
+    def select_model(self, observations, n_samples=1000, n_samples_per_param=1):
         """        
         Parameters
         ----------
@@ -142,10 +143,10 @@ def select_model(self, observations, n_samples = 1000, n_samples_per_param = 1):
         self.observations_bds = self.backend.broadcast(observations)
 
         # Creation of reference table
-        if self.reference_table_calculated is 0:        
+        if self.reference_table_calculated is 0:
             # Simulating the data, distance and statistics
-            seed_arr = self.rng.randint(1, n_samples*n_samples, size=n_samples, dtype=np.int32)
-            seed_pds = self.backend.parallelize(seed_arr)     
+            seed_arr = self.rng.randint(1, n_samples * n_samples, size=n_samples, dtype=np.int32)
+            seed_pds = self.backend.parallelize(seed_arr)
 
             model_data_pds = self.backend.map(self._simulate_model_data, seed_pds)
             model_data = self.backend.collect(model_data_pds)
@@ -157,19 +158,21 @@ def select_model(self, observations, n_samples = 1000, n_samples_per_param = 1):
 
         # Construct a label for the model_array
         label = np.zeros(shape=(len(self.reference_table_models)))
-        for ind1 in range(len(self.reference_table_models)):  
+        for ind1 in range(len(self.reference_table_models)):
             for ind2 in range(len(self.model_array)):
                 if self.reference_table_models[ind1] == self.model_array[ind2]:
-                    label[ind1] = ind2 
+                    label[ind1] = ind2
 
-        # Define the classifier 
-        classifier = ensemble.RandomForestClassifier(n_estimators = self.N_tree, \
-        max_features=int(self.n_try_fraction*self.reference_table_statistics.shape[1]), bootstrap=True, random_state=self.seed)
-        classifier.fit(self.reference_table_statistics, label)            
+                    # Define the classifier
+        classifier = ensemble.RandomForestClassifier(n_estimators=self.N_tree, \
+                                                     max_features=int(
+                                                         self.n_try_fraction * self.reference_table_statistics.shape[
+                                                             1]), bootstrap=True, random_state=self.seed)
+        classifier.fit(self.reference_table_statistics, label)
 
-        return(self.model_array[int(classifier.predict(self.statistics_calc.statistics(observations)))])
+        return self.model_array[int(classifier.predict(self.statistics_calc.statistics(observations)))]
 
-    def posterior_probability(self, observations, n_samples = 1000, n_samples_per_param = 1):
+    def posterior_probability(self, observations, n_samples=1000, n_samples_per_param=1):
 
         """
         Parameters
@@ -185,10 +188,10 @@ def posterior_probability(self, observations, n_samples = 1000, n_samples_per_pa
         self.n_samples_per_param = 1
         self.observations_bds = self.backend.broadcast(observations)
         # Creation of reference table
-        if self.reference_table_calculated is 0:        
+        if self.reference_table_calculated is 0:
             # Simulating the data, distance and statistics
-            seed_arr = self.rng.randint(1, n_samples*n_samples, size=n_samples, dtype=np.int32)
-            seed_pds = self.backend.parallelize(seed_arr)     
+            seed_arr = self.rng.randint(1, n_samples * n_samples, size=n_samples, dtype=np.int32)
+            seed_pds = self.backend.parallelize(seed_arr)
 
             model_data_pds = self.backend.map(self._simulate_model_data, seed_pds)
             model_data = self.backend.collect(model_data_pds)
@@ -197,29 +200,33 @@ def posterior_probability(self, observations, n_samples = 1000, n_samples_per_pa
             self.reference_table_data = data
             self.reference_table_statistics = np.concatenate(statistics)
             self.reference_table_calculated = 1
-        
+
         # Construct a label for the model_array
         label = np.zeros(shape=(len(self.reference_table_models)))
-        for ind1 in range(len(self.reference_table_models)):  
+        for ind1 in range(len(self.reference_table_models)):
             for ind2 in range(len(self.model_array)):
                 if self.reference_table_models[ind1] == self.model_array[ind2]:
-                    label[ind1] = ind2 
+                    label[ind1] = ind2
 
-        # Define the classifier 
-        classifier = ensemble.RandomForestClassifier(n_estimators = self.N_tree, \
-        max_features=int(self.n_try_fraction*self.reference_table_statistics.shape[1]), bootstrap=True, random_state=self.seed)
-        classifier.fit(self.reference_table_statistics, label)  
+                    # Define the classifier
+        classifier = ensemble.RandomForestClassifier(n_estimators=self.N_tree, \
+                                                     max_features=int(
+                                                         self.n_try_fraction * self.reference_table_statistics.shape[
+                                                             1]), bootstrap=True, random_state=self.seed)
+        classifier.fit(self.reference_table_statistics, label)
 
-        pred_error = np.zeros(len(self.reference_table_models),)
+        pred_error = np.zeros(len(self.reference_table_models), )
         # Compute missclassification error rate
         for ind in range(len(self.reference_table_models)):
-            pred_error[ind] = 1 - classifier.predict_proba(self.statistics_calc.statistics(self.reference_table_data[ind]))[0][int(label[ind])] 
+            pred_error[ind] = 1 - \
+                              classifier.predict_proba(self.statistics_calc.statistics(self.reference_table_data[ind]))[
+                                  0][int(label[ind])]
 
-        # Estimate a regression function with prediction error as response on summary statitistics of the reference table                
-        regressor = ensemble.RandomForestRegressor(n_estimators = self.N_tree)
-        regressor.fit(self.reference_table_statistics,pred_error)
+            # Estimate a regression function with prediction error as response on summary statitistics of the reference table
+        regressor = ensemble.RandomForestRegressor(n_estimators=self.N_tree)
+        regressor.fit(self.reference_table_statistics, pred_error)
 
-        return(1-regressor.predict(self.statistics_calc.statistics(observations)))
+        return 1 - regressor.predict(self.statistics_calc.statistics(observations))
 
     def _simulate_model_data(self, seed):
         """
@@ -243,9 +250,9 @@ def _simulate_model_data(self, seed):
                                          * rng.multinomial(1, (1 / len_model_array) * np.ones(len_model_array))))]
         self.sample_from_prior([model], rng=rng)
         y_sim = model.forward_simulate(model.get_input_values(), self.n_samples_per_param, rng=rng)
-        while(y_sim[0] is False):
-            y_sim = model.forward_simulate(model.get_input_values() ,self.n_samples_per_param, rng=rng)
+        while y_sim[0] is False:
+            y_sim = model.forward_simulate(model.get_input_values(), self.n_samples_per_param, rng=rng)
         y_sim = y_sim[0].tolist()
         statistics = self.statistics_calc.statistics(y_sim)
 
-        return (model, y_sim, statistics)
\ No newline at end of file
+        return model, y_sim, statistics
diff --git a/abcpy/multilevel.py b/abcpy/multilevel.py
index ce1aa02d..12ad8326 100644
--- a/abcpy/multilevel.py
+++ b/abcpy/multilevel.py
@@ -1,8 +1,6 @@
 from abc import ABCMeta, abstractmethod
 
 import numpy as np
-from glmnet import LogitNet
-from sklearn import linear_model
 
 
 class Multilevel(metaclass=ABCMeta):
@@ -82,7 +80,7 @@ def flat_map(self, data, n_repeat, map_function):
         seed_arr = self.rng.randint(1, n_total * n_total, size=n_total, dtype=np.int32)
         rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
         # Create data and rng array
-        repeated_data_rng = [[repeated_data[ind,:],rng_arr[ind]] for ind in range(n_total)]
+        repeated_data_rng = [[repeated_data[ind, :], rng_arr[ind]] for ind in range(n_total)]
         repeated_data_rng_pds = self.backend.parallelize(repeated_data_rng)
         # Map the function on the data using the corresponding rng
         repeated_data_result_pds = self.backend.map(map_function, repeated_data_rng_pds)
@@ -98,4 +96,3 @@ def flat_map(self, data, n_repeat, map_function):
 
 
 class Prototype(Multilevel):
-    
\ No newline at end of file
diff --git a/abcpy/output.py b/abcpy/output.py
index 9e4ceeae..fdda266c 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -89,7 +89,7 @@ def add_user_parameters(self, names_and_params):
             Each entry is a tuple, where the first entry is the name of the probabilistic model, and the second entry is
             the parameters associated with this model.
         """
-        if (self._type == 0):
+        if self._type == 0:
             self.names_and_parameters = [dict(names_and_params)]
         else:
             self.names_and_parameters.append(dict(names_and_params))
diff --git a/abcpy/perturbationkernel.py b/abcpy/perturbationkernel.py
index 39163e75..796d077d 100644
--- a/abcpy/perturbationkernel.py
+++ b/abcpy/perturbationkernel.py
@@ -7,7 +7,7 @@
 from abcpy.probabilisticmodels import Continuous
 
 
-class PerturbationKernel(metaclass = ABCMeta):
+class PerturbationKernel(metaclass=ABCMeta):
     """This abstract base class represents all perturbation kernels"""
 
     @abstractmethod
@@ -21,7 +21,6 @@ def __init__(self, models):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def calculate_cov(self, accepted_parameters_manager, kernel_index):
         """
@@ -42,7 +41,6 @@ def calculate_cov(self, accepted_parameters_manager, kernel_index):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def update(self, accepted_parameters_manager, row_index, rng):
         """
@@ -65,7 +63,6 @@ def update(self, accepted_parameters_manager, row_index, rng):
 
         raise NotImplementedError
 
-
     def pdf(self, accepted_parameters_manager, kernel_index, row_index, x):
         """
         Calculates the pdf of the kernel at point x.
@@ -88,13 +85,13 @@ def pdf(self, accepted_parameters_manager, kernel_index, row_index, x):
 
         """
 
-        if(isinstance(self, DiscreteKernel)):
+        if isinstance(self, DiscreteKernel):
             return self.pmf(accepted_parameters_manager, kernel_index, row_index, x)
         else:
             raise NotImplementedError
 
 
-class ContinuousKernel(metaclass = ABCMeta):
+class ContinuousKernel(metaclass=ABCMeta):
     """This abstract base class represents all perturbation kernels acting on continuous parameters."""
 
     @abstractmethod
@@ -102,7 +99,7 @@ def pdf(self, accepted_parameters_manager, kernel_index, index, x):
         raise NotImplementedError
 
 
-class DiscreteKernel(metaclass = ABCMeta):
+class DiscreteKernel(metaclass=ABCMeta):
     """This abstract base class represents all perturbation kernels acting on discrete parameters."""
 
     @abstractmethod
@@ -126,7 +123,6 @@ def __init__(self, kernels):
         self._check_kernels(kernels)
         self.kernels = kernels
 
-
     def calculate_cov(self, accepted_parameters_manager):
         """
         Calculates the covariance matrix corresponding to each kernel. Commonly used before calculating weights to avoid
@@ -148,7 +144,6 @@ def calculate_cov(self, accepted_parameters_manager):
             all_covs.append(kernel.calculate_cov(accepted_parameters_manager, kernel_index))
         return all_covs
 
-
     def _check_kernels(self, kernels):
         """
         Checks whether each model is only used in one perturbation kernel. Commonly called from the constructor.
@@ -163,11 +158,10 @@ def _check_kernels(self, kernels):
         for kernel in kernels:
             for model in kernel.models:
                 for already_contained_model in models:
-                    if(already_contained_model==model):
+                    if already_contained_model == model:
                         raise ValueError("No two kernels can perturb the same probabilistic model.")
                 models.append(model)
 
-
     def update(self, accepted_parameters_manager, row_index, rng=np.random.RandomState()):
         """
         Perturbs the parameter values contained in accepted_parameters_manager. Commonly used while perturbing.
@@ -198,17 +192,16 @@ def update(self, accepted_parameters_manager, row_index, rng=np.random.RandomSta
 
         # Match the results from the perturbations and their models
         for kernel_index, kernel in enumerate(self.kernels):
-            index=0
+            index = 0
             for model in kernel.models:
                 model_values = []
-                #for j in range(model.get_output_dimension()):
+                # for j in range(model.get_output_dimension()):
                 model_values.append(perturbed_values[kernel_index][index])
-                index+=1
+                index += 1
                 perturbed_values_including_models.append((model, model_values))
 
         return perturbed_values_including_models
 
-
     def pdf(self, mapping, accepted_parameters_manager, mean, x):
         """
         Calculates the overall pdf of the kernel. Commonly used to calculate weights.
@@ -236,10 +229,10 @@ def pdf(self, mapping, accepted_parameters_manager, mean, x):
             mean_kernel, theta = [], []
             for kernel_model in kernel.models:
                 for model, model_output_index in mapping:
-                    if(kernel_model==model):
+                    if kernel_model == model:
                         theta.append(x[model_output_index])
                         mean_kernel.append(mean[model_output_index])
-            result*=kernel.pdf(accepted_parameters_manager, kernel_index, mean_kernel, theta)
+            result *= kernel.pdf(accepted_parameters_manager, kernel_index, mean_kernel, theta)
 
         return result
 
@@ -278,14 +271,13 @@ def calculate_cov(self, accepted_parameters_manager, kernel_index):
                     accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][i])
         continuous_model = np.array(continuous_model).astype(float)
 
-        if(accepted_parameters_manager.accepted_weights_bds is not None):
+        if accepted_parameters_manager.accepted_weights_bds is not None:
             weights = accepted_parameters_manager.accepted_weights_bds.value()
             cov = np.cov(continuous_model, aweights=weights.reshape(-1).astype(float), rowvar=False)
         else:
             cov = np.cov(continuous_model, rowvar=False)
         return cov
 
-
     def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.random.RandomState()):
         """
         Updates the parameter values contained in the accepted_paramters_manager using a multivariate normal distribution.
@@ -310,7 +302,8 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
         # Get all current parameter values relevant for this model and the structure
         continuous_model_values = accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index]
 
-        if isinstance(continuous_model_values[row_index][0], (np.float, np.float32, np.float64, np.int, np.int32, np.int64)):
+        if isinstance(continuous_model_values[row_index][0],
+                      (np.float, np.float32, np.float64, np.int, np.int32, np.int64)):
             # Perturb
             cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
             continuous_model_values = np.array(continuous_model_values).astype(float)
@@ -318,7 +311,7 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
             # Perturbed values anc split according to the structure
             perturbed_continuous_values = rng.multivariate_normal(continuous_model_values[row_index], cov)
         else:
-            #print('Hello')
+            # print('Hello')
             # Learn the structure
             struct = [[] for i in range(len(continuous_model_values[row_index]))]
             for i in range(len(continuous_model_values[row_index])):
@@ -335,7 +328,6 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
 
         return perturbed_continuous_values
 
-
     def pdf(self, accepted_parameters_manager, kernel_index, mean, x):
         """Calculates the pdf of the kernel.
         Commonly used to calculate weights.
@@ -381,7 +373,6 @@ def __init__(self, models, df):
         self.models = models
         self.df = df
 
-
     def calculate_cov(self, accepted_parameters_manager, kernel_index):
         """
         Calculates the covariance matrix relevant to this kernel.
@@ -409,14 +400,13 @@ def calculate_cov(self, accepted_parameters_manager, kernel_index):
                     accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][i])
         continuous_model = np.array(continuous_model).astype(float)
 
-        if(accepted_parameters_manager.accepted_weights_bds is not None):
+        if accepted_parameters_manager.accepted_weights_bds is not None:
             weights = np.array(accepted_parameters_manager.accepted_weights_bds.value())
-            cov = np.cov(continuous_model, aweights=weights.reshape(-1).astype(float),rowvar=False)
+            cov = np.cov(continuous_model, aweights=weights.reshape(-1).astype(float), rowvar=False)
         else:
             cov = np.cov(continuous_model, rowvar=False)
         return cov
 
-
     def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.random.RandomState()):
         """
         Updates the parameter values contained in the accepted_paramters_manager using a multivariate normal distribution.
@@ -449,7 +439,7 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
             cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
             p = len(continuous_model_values)
 
-            if (self.df == np.inf):
+            if self.df == np.inf:
                 chisq = 1.0
             else:
                 chisq = rng.chisquare(self.df, 1) / self.df
@@ -469,7 +459,7 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
             cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
             p = len(continuous_model_values)
 
-            if (self.df == np.inf):
+            if self.df == np.inf:
                 chisq = 1.0
             else:
                 chisq = rng.chisquare(self.df, 1) / self.df
@@ -528,11 +518,13 @@ def pdf(self, accepted_parameters_manager, kernel_index, mean, x):
             numerator = gamma((v + p) / 2)
             denominator = gamma(v / 2) * pow(v * np.pi, p / 2.) * np.sqrt(abs(np.linalg.det(cov)))
             normalizing_const = numerator / denominator
-            tmp = 1 + 1 / v * np.dot(np.dot(np.transpose(np.concatenate(x) - mean), np.linalg.inv(cov)), (np.concatenate(x) - mean))
+            tmp = 1 + 1 / v * np.dot(np.dot(np.transpose(np.concatenate(x) - mean), np.linalg.inv(cov)),
+                                     (np.concatenate(x) - mean))
             density = normalizing_const * pow(tmp, -((v + p) / 2.))
 
             return density
 
+
 class RandomWalkKernel(PerturbationKernel, DiscreteKernel):
     def __init__(self, models):
         """
@@ -578,15 +570,13 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
 
         return perturbed_discrete_values
 
-
     def calculate_cov(self, accepted_parameters_manager, kernel_index):
         """
         Calculates the covariance matrix of this kernel. Since there is no covariance matrix associated with this
         random walk, it returns an empty list.
         """
 
-        return np.array([0]).reshape(-1,)
-
+        return np.array([0]).reshape(-1, )
 
     def pmf(self, accepted_parameters_manager, kernel_index, mean, x):
         """
@@ -610,7 +600,7 @@ def pmf(self, accepted_parameters_manager, kernel_index, mean, x):
             The pmf evaluated at point x.
         """
 
-        return 1./3
+        return 1. / 3
 
 
 class DefaultKernel(JointPerturbationKernel):
@@ -628,16 +618,15 @@ def __init__(self, models):
         continuous_models = []
         discrete_models = []
         for model in models:
-            if(isinstance(model, Continuous)):
+            if isinstance(model, Continuous):
                 continuous_models.append(model)
             else:
                 discrete_models.append(model)
         continuous_kernel = MultivariateNormalKernel(continuous_models)
         discrete_kernel = RandomWalkKernel(discrete_models)
-        if(not(continuous_models)):
+        if not continuous_models:
             super(DefaultKernel, self).__init__([discrete_kernel])
-        elif(not(discrete_models)):
+        elif not discrete_models:
             super(DefaultKernel, self).__init__([continuous_kernel])
         else:
             super(DefaultKernel, self).__init__([continuous_kernel, discrete_kernel])
-
diff --git a/abcpy/probabilisticmodels.py b/abcpy/probabilisticmodels.py
index 79e7de10..93eb98dc 100644
--- a/abcpy/probabilisticmodels.py
+++ b/abcpy/probabilisticmodels.py
@@ -1,9 +1,10 @@
 from abc import ABCMeta, abstractmethod
 from numbers import Number
+
 import numpy as np
 
 
-class InputConnector():
+class InputConnector:
     def __init__(self, dimension):
         """
         Creates input parameters of given dimensionality. Each dimension needs to be specified using the set method.
@@ -16,9 +17,8 @@ def __init__(self, dimension):
 
         self._all_indices_specified = False
         self._dimension = dimension
-        self._models = [None]*dimension
-        self._model_indices = [None]*dimension
-
+        self._models = [None] * dimension
+        self._model_indices = [None] * dimension
 
     def from_number(number):
         """
@@ -40,7 +40,6 @@ def from_number(number):
         else:
             raise TypeError('Unsupported type.')
 
-
     def from_model(model):
         """
         Convenient initializer that converts the full output of a model to input parameters.
@@ -62,7 +61,6 @@ def from_model(model):
         else:
             raise TypeError('Unsupported type.')
 
-
     def from_list(parameters):
         """
         Creates an InputParameters object from a list of ProbabilisticModels.
@@ -114,8 +112,6 @@ def from_list(parameters):
         else:
             raise TypeError('Input is not a list')
 
-
-
     def __getitem__(self, index):
         """
         For the input models, return those fixed value(s) that are specified by index.
@@ -135,7 +131,7 @@ def __getitem__(self, index):
         """
 
         # index is a single number
-        if isinstance (index, Number):
+        if isinstance(index, Number):
             model = self._models[index]
             model_index = self._model_indices[index]
             if model.get_stored_output_values() is None:
@@ -155,7 +151,6 @@ def __getitem__(self, index):
                     return None
             return result
 
-
     def get_values(self):
         """
         Returns the fixed values of all input models.
@@ -165,12 +160,11 @@ def get_values(self):
         np.array
         """
 
-        result = [0]*self._dimension
+        result = [0] * self._dimension
         for i in range(0, self._dimension):
             result[i] = self.__getitem__(i)
         return result
 
-
     def get_models(self):
         """
         Returns a list of all models.
@@ -182,7 +176,6 @@ def get_models(self):
 
         return self._models
 
-
     def get_model(self, index):
         """
         Returns the model at index.
@@ -194,7 +187,6 @@ def get_model(self, index):
 
         return self._models[index]
 
-
     def get_parameter_count(self):
         """
         Returns the number of parameters.
@@ -206,7 +198,6 @@ def get_parameter_count(self):
 
         return self._dimension
 
-
     def set(self, index, model, model_index):
         """
         Sets for an input parameter index the input model and the model index to use.
@@ -228,10 +219,9 @@ def set(self, index, model, model_index):
 
         self._models[index] = model
         self._model_indices[index] = model_index
-        if (self._models != None):
+        if self._models != None:
             self._all_indices_specified = True
 
-
     def all_models_fixed_values(self):
         """
         Checks whether all input models have fixed an output value (pseudo data).
@@ -250,7 +240,7 @@ def all_models_fixed_values(self):
         return True
 
 
-class ProbabilisticModel(metaclass = ABCMeta):
+class ProbabilisticModel(metaclass=ABCMeta):
     """
     This abstract class represents all probabilistic models.
     """
@@ -271,7 +261,6 @@ def __init__(self, input_connector, name=''):
             A human readable name for the model. Can be the variable name for example.
         """
 
-
         # set name
         self.name = name
 
@@ -289,7 +278,6 @@ def __init__(self, input_connector, name=''):
         self.visited = False
         self.calculated_pdf = None
 
-
     def __getitem__(self, item):
         """
         Overloads the access operator. If the access operator is called, a tuple of the ProbablisticModel that called
@@ -303,15 +291,15 @@ def __getitem__(self, item):
         """
 
         if isinstance(item, Number):
-            if(item>=self.get_output_dimension()):
-                raise IndexError('The specified index lies out of range for probabilistic model %s.'%(self.__class__.__name__))
+            if item >= self.get_output_dimension():
+                raise IndexError(
+                    'The specified index lies out of range for probabilistic model %s.' % self.__class__.__name__)
             input_parameters = InputConnector(1)
             input_parameters.set(0, self, item)
             return input_parameters
         else:
             raise TypeError('Input of unsupported type.')
 
-
     def get_input_values(self):
         """
         Returns the input values from the parent models as a list.
@@ -324,7 +312,6 @@ def get_input_values(self):
 
         return self.get_input_connector().get_values()
 
-
     def get_input_models(self):
         """
         Returns a list of all input models.
@@ -337,7 +324,6 @@ def get_input_models(self):
         input_connector = self.get_input_connector()
         return input_connector.get_models()
 
-
     def get_stored_output_values(self):
         """
         Returns the stored sampled value of the probabilistic model after setting the values explicitly.
@@ -351,7 +337,6 @@ def get_stored_output_values(self):
 
         return self._fixed_values
 
-
     def get_input_connector(self):
         """
         Returns the input connector object that connecects the current model to its parents.
@@ -365,7 +350,6 @@ def get_input_connector(self):
 
         return self._parameters
 
-
     def get_input_dimension(self):
         """
         Returns the input dimension of the current model.
@@ -378,7 +362,6 @@ def get_input_dimension(self):
 
         return self._parameters._dimension
 
-
     def set_output_values(self, values):
         """
         Sets the output values of the model. This method is commonly used to set new values after perturbing the old
@@ -404,7 +387,6 @@ def set_output_values(self, values):
             return True
         return False
 
-
     def __add__(self, other):
         """Overload the + operator for probabilistic models.
 
@@ -418,8 +400,7 @@ def __add__(self, other):
         SummationModel
             A probabilistic model describing a model coming from summation.
         """
-        return SummationModel([self,other])
-
+        return SummationModel([self, other])
 
     def __radd__(self, other):
         """Overload the + operator from the righthand side to support addition of Hyperparameters from the left.
@@ -436,7 +417,6 @@ def __radd__(self, other):
         """
         return SummationModel([other, self])
 
-
     def __sub__(self, other):
         """Overload the - operator for probabilistic models.
 
@@ -452,7 +432,6 @@ def __sub__(self, other):
         """
         return SubtractionModel([self, other])
 
-
     def __rsub__(self, other):
         """Overload the - operator from the righthand side to support subtraction of Hyperparameters from the left.
 
@@ -466,8 +445,7 @@ def __rsub__(self, other):
         SubtractionModel
             A probabilistic model describing a model coming from subtraction.
         """
-        return SubtractionModel([other,self])
-
+        return SubtractionModel([other, self])
 
     def __mul__(self, other):
         """Overload the * operator for probabilistic models.
@@ -482,8 +460,7 @@ def __mul__(self, other):
         MultiplicationModel
             A probabilistic model describing a model coming from multiplication.
         """
-        return MultiplicationModel([self,other])
-
+        return MultiplicationModel([self, other])
 
     def __rmul__(self, other):
         """Overload the * operator from the righthand side to support subtraction of Hyperparameters from the left.
@@ -498,8 +475,7 @@ def __rmul__(self, other):
                 MultiplicationModel
                     A probabilistic model describing a model coming from multiplication.
                 """
-        return MultiplicationModel([other,self])
-
+        return MultiplicationModel([other, self])
 
     def __truediv__(self, other):
         """Overload the / operator for probabilistic models.
@@ -516,7 +492,6 @@ def __truediv__(self, other):
         """
         return DivisionModel([self, other])
 
-
     def __rtruediv__(self, other):
         """Overload the / operator from the righthand side to support subtraction of Hyperparameters from the left.
 
@@ -532,15 +507,12 @@ def __rtruediv__(self, other):
         """
         return DivisionModel([other, self])
 
-
     def __pow__(self, power, modulo=None):
         return ExponentialModel([self, power])
 
-
     def __rpow__(self, other):
         return RExponentialModel([other, self])
 
-
     def _forward_simulate_and_store_output(self, rng=np.random.RandomState()):
         """
         Samples from the model associated and assigns the result to fixed_values, if applicable. Commonly used when
@@ -558,14 +530,13 @@ def _forward_simulate_and_store_output(self, rng=np.random.RandomState()):
         """
 
         parameters_are_valid = self._check_input(self.get_input_values())
-        if(parameters_are_valid):
+        if parameters_are_valid:
             sample_result = self.forward_simulate(self.get_input_values(), 1, rng=rng)
             if sample_result != None:
                 self.set_output_values(sample_result[0])
                 return True
         return False
 
-
     def pdf(self, input_values, x):
         """
         Calculates the probability density function at point x.
@@ -585,12 +556,11 @@ def pdf(self, input_values, x):
             The pdf evaluated at point x.
         """
         # If the probabilistic model is discrete, there is no probability density function, but a probability mass function. This check ensures that calling the pdf of such a model still works.
-        if(isinstance(self, Discrete)):
+        if isinstance(self, Discrete):
             return self.pmf(input_values, x)
         else:
             raise NotImplementedError
 
-
     def calculate_and_store_pdf_if_needed(self, x):
         """
         Calculates the probability density function at point x and stores the result internally for later use.
@@ -606,7 +576,6 @@ def calculate_and_store_pdf_if_needed(self, x):
         if self._calculated_pdf == None:
             self._calculated_pdf = self.pdf(self.get_input_values(), x)
 
-
     def flush_stored_pdf(self):
         """
         This function flushes the internally stored value of a previously computed pdf.
@@ -614,7 +583,6 @@ def flush_stored_pdf(self):
 
         self._calculated_pdf = None
 
-
     def get_stored_pdf(self):
         """
         Retrieves the value of a previously calculated pdf.
@@ -626,7 +594,6 @@ def get_stored_pdf(self):
 
         return self._calculated_pdf
 
-
     @abstractmethod
     def _check_input(self, input_values):
         """
@@ -659,7 +626,6 @@ def _check_input(self, input_values):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def _check_output(self, values):
         """
@@ -678,7 +644,6 @@ def _check_output(self, values):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def forward_simulate(self, input_values, k, rng, mpi_comm=None):
         """
@@ -714,7 +679,6 @@ def forward_simulate(self, input_values, k, rng, mpi_comm=None):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def get_output_dimension(self):
         """
@@ -733,7 +697,7 @@ def get_output_dimension(self):
         raise NotImplementedError
 
 
-class Continuous(metaclass = ABCMeta):
+class Continuous(metaclass=ABCMeta):
     """
     This abstract class represents all continuous probabilistic models.
     """
@@ -755,7 +719,7 @@ def pdf(self, input_values, x):
         raise NotImplementedError
 
 
-class Discrete(metaclass = ABCMeta):
+class Discrete(metaclass=ABCMeta):
     """
     This abstract class represents all discrete probabilistic models.
     """
@@ -782,6 +746,7 @@ class Hyperparameter(ProbabilisticModel):
     This class represents all hyperparameters (i.e. fixed parameters).
 
     """
+
     def __init__(self, value, name='Hyperparameter'):
         """
 
@@ -796,12 +761,10 @@ def __init__(self, value, name='Hyperparameter'):
         self._fixed_values = np.array([value])
         self.visited = False
 
-
     def _forward_simulate_and_store_output(self, rng=np.random.RandomState()):
         self.visited = True
         return True
 
-
     def _check_input(self, input_values):
         """
         Hyperparameters have no input, thus we only accept None.
@@ -813,11 +776,9 @@ def _check_input(self, input_values):
             return True
         return False
 
-
     def _check_output(self, values):
         return False
 
-
     def set_output_values(self, values, rng=np.random.RandomState()):
         if not isinstance(values, np.ndarray):
             raise TypeError('Input not a numpy.array.')
@@ -825,30 +786,24 @@ def set_output_values(self, values, rng=np.random.RandomState()):
             raise IndexError('Dimensions not matching.')
         return False
 
-
     def get_input_dimension(self):
         return 0;
 
     def get_output_dimension(self):
         return 1;
 
-
     def get_input_connector(self):
         return None
 
-
     def get_input_models(self):
         return []
 
-
     def get_input_values(self):
         return []
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         return [np.array(self._fixed_values) for _ in range(k)]
 
-
     def pdf(self, input_values, x):
         # Mathematically, the expression for the pdf of a hyperparameter should be: if(x==self.fixed_parameters) return
         # 1; else return 0; However, since the pdf is called recursively for the whole model structure, and pdfs
@@ -890,24 +845,19 @@ def __init__(self, parameters, name=''):
         input_parameters = InputConnector.from_list(parameters)
         super(ModelResultingFromOperation, self).__init__(input_parameters, name)
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         raise NotImplementedError
 
-
     def _check_input(self, input_values):
         return True
 
-
     def _check_output(self, parameters):
         """Checks parameters while setting them. Provided due to inheritance."""
         return True
 
-
     def get_output_dimension(self):
         return self._dimension
 
-
     def pdf(self, input_values, x):
         """Calculates the probability density function at point x.
 
@@ -1009,9 +959,9 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
             # add the corresponding parameter_values
             sample_value = []
             for j in range(self.get_output_dimension()):
-                sample_value.append(parameter_values[j]+parameter_values[j+self.get_output_dimension()])
-            if(len(sample_value)==1):
-                sample_value=sample_value[0]
+                sample_value.append(parameter_values[j] + parameter_values[j + self.get_output_dimension()])
+            if len(sample_value) == 1:
+                sample_value = sample_value[0]
             return_value.append(sample_value)
 
         return return_value
@@ -1056,8 +1006,8 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
             sample_value = []
             for j in range(self.get_output_dimension()):
                 sample_value.append(parameter_values[j] - parameter_values[j + self.get_output_dimension()])
-            if(len(sample_value)==1):
-                sample_value=sample_value[0]
+            if len(sample_value) == 1:
+                sample_value = sample_value[0]
             return_value.append(sample_value)
 
         return return_value
@@ -1065,6 +1015,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
 
 class MultiplicationModel(ModelResultingFromOperation):
     """This class represents all probabilistic models resulting from a multiplication of two probabilistic models"""
+
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """Multiplies the sampled values of both parent distributions element wise.
 
@@ -1099,8 +1050,8 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
             sample_value = []
 
             for j in range(self.get_output_dimension()):
-                sample_value.append(parameter_values[j] * parameter_values[j+self.get_output_dimension()])
-            if (len(sample_value) == 1):
+                sample_value.append(parameter_values[j] * parameter_values[j + self.get_output_dimension()])
+            if len(sample_value) == 1:
                 sample_value = sample_value[0]
             return_value.append(sample_value)
 
@@ -1144,7 +1095,7 @@ def forward_simulate(self, input_valus, k, rng=np.random.RandomState(), mpi_comm
             sample_value = []
 
             for j in range(self.get_output_dimension()):
-                sample_value.append(parameter_values[j]/parameter_values[j + self.get_output_dimension()])
+                sample_value.append(parameter_values[j] / parameter_values[j + self.get_output_dimension()])
             return_value += sample_value
 
         return return_value
@@ -1170,11 +1121,9 @@ def __init__(self, parameters, name=''):
 
         super(ExponentialModel, self).__init__(parameters, name)
 
-
     def _check_input(self, input_values):
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """Raises the sampled values of the base by the exponent.
 
@@ -1210,7 +1159,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
             sample_value = []
 
             for j in range(self.get_output_dimension()):
-                sample_value.append(parameter_values[j]**power)
+                sample_value.append(parameter_values[j] ** power)
             result.append(np.array(sample_value))
 
         return result
@@ -1235,11 +1184,9 @@ def __init__(self, parameters, name=''):
                 raise ValueError('The exponent can only be 1 dimensional.')
         super(RExponentialModel, self).__init__(parameters, name)
 
-
     def _check_input(self, input_values):
         return True
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_comm=None):
         """Raises the base by the sampled value of the exponent.
 
@@ -1279,4 +1226,3 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
             result.append(sample_value)
 
         return [np.array(result)]
-
diff --git a/abcpy/statistics.py b/abcpy/statistics.py
index 1b190338..6f2474c1 100644
--- a/abcpy/statistics.py
+++ b/abcpy/statistics.py
@@ -78,7 +78,7 @@ def _polynomial_expansion(self, summary_statistics):
         Returns
         -------
         numpy.ndarray
-            nx(p+degree*p+cross*nchoosek(p,2)) matrix where for each of the n pointss with
+            nx(p+degree*p+cross*nchoosek(p,2)) matrix where for each of the n points with
             p statistics, degree*p polynomial expansion term and cross*nchoosek(p,2) many
             cross-product terms are calculated.
 
diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 3311b7a5..522abfba 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -99,7 +99,7 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_va
 
         n_samples_to_generate = n_samples * (parameters is None) + n_samples_val * (parameters_val is None)
 
-        if n_samples_to_generate > 0:  # need to generate some data 
+        if n_samples_to_generate > 0:  # need to generate some data
             self.logger.info('Generation of data...')
 
             self.logger.debug("Definitions for parallelization.")
diff --git a/examples/approx_lhd/pmc_hierarchical_models.py b/examples/approx_lhd/pmc_hierarchical_models.py
index 03a14476..c6b34786 100644
--- a/examples/approx_lhd/pmc_hierarchical_models.py
+++ b/examples/approx_lhd/pmc_hierarchical_models.py
@@ -1,9 +1,22 @@
-import numpy as np
-
 """An example showing how to implement a bayesian network in ABCpy"""
+
+
 def infer_parameters():
     # The data corresponding to model_1 defined below
-    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368, 4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294, 3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705, 3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419, 4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124, 4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361, 4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868, 4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221, 4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768, 4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518, 4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284, 4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087, 4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748, 3.8668863066511303, 3.8837108501541007]
+    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
+                  4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
+                  3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705,
+                  3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419,
+                  4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124,
+                  4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361,
+                  4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868,
+                  4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221,
+                  4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768,
+                  4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518,
+                  4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284,
+                  4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087,
+                  4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748,
+                  3.8668863066511303, 3.8837108501541007]
 
     # The prior information changing the class size and social background, depending on school location
     from abcpy.continuousmodels import Uniform, Normal
@@ -19,21 +32,34 @@ def infer_parameters():
     grade_without_additional_effects = Normal([[4.5], [0.25]], )
 
     # The grade a student of a certain school receives
-    final_grade = grade_without_additional_effects-class_size-background
+    final_grade = grade_without_additional_effects - class_size - background
 
     # The data corresponding to model_2 defined below
-    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192, 3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992, 2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971, 2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507, 3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989, 2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755, 2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858, 2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202, 2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186, 3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073, 2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045, 3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465, 2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546, 1.0893224045062178, 0.8032302688764734, 2.868438615047827]
+    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192,
+                       3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992,
+                       2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971,
+                       2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507,
+                       3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989,
+                       2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755,
+                       2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858,
+                       2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202,
+                       2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186,
+                       3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073,
+                       2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045,
+                       3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465,
+                       2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546,
+                       1.0893224045062178, 0.8032302688764734, 2.868438615047827]
 
     # A quantity that determines whether a student will receive a scholarship
     scholarship_without_additional_effects = Normal([[2], [0.5]], )
 
     # A quantity determining whether a student receives a scholarship, including his social background
-    final_scholarship = scholarship_without_additional_effects + 3*background
+    final_scholarship = scholarship_without_additional_effects + 3 * background
 
     # Define a summary statistics for final grade and final scholarship
     from abcpy.statistics import Identity
-    statistics_calculator_final_grade = Identity(degree = 2, cross = False)
-    statistics_calculator_final_scholarship = Identity(degree = 3, cross = False)
+    statistics_calculator_final_grade = Identity(degree=2, cross=False)
+    statistics_calculator_final_scholarship = Identity(degree=3, cross=False)
 
     # Define a distance measure for final grade and final scholarship
     from abcpy.approx_lhd import SynLikelihood
@@ -55,7 +81,7 @@ def infer_parameters():
     # Define sampler
     from abcpy.inferences import PMC
     sampler = PMC([final_grade, final_scholarship], \
-                     [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel)
+                  [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel)
 
     # Sample
     journal = sampler.sample([grades_obs, scholarship_obs], T, n_sample, n_samples_per_param)
@@ -80,6 +106,7 @@ def analyse_journal(journal):
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
diff --git a/examples/backends/apache_spark/pmcabc_gaussian.py b/examples/backends/apache_spark/pmcabc_gaussian.py
index 78639c35..eac5994c 100644
--- a/examples/backends/apache_spark/pmcabc_gaussian.py
+++ b/examples/backends/apache_spark/pmcabc_gaussian.py
@@ -1,8 +1,9 @@
 import numpy as np
 
+
 def setup_backend():
     global backend
-    
+
     import pyspark
     sc = pyspark.SparkContext()
     from abcpy.backends import BackendSpark as Backend
@@ -11,7 +12,18 @@ def setup_backend():
 
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
+             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
+             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
+             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
+             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
+             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
+             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
+             202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -23,7 +35,7 @@ def infer_parameters():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import LogReg
@@ -32,12 +44,12 @@ def infer_parameters():
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([model], distance_calculator, backend, seed=1)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -46,15 +58,15 @@ def analyse_journal(journal):
     # output parameters and weights
     print(journal.parameters)
     print(journal.weights)
-    
+
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
     print(journal.posterior_histogram())
-    
+
     # print configuration
     print(journal.configuration)
-    
+
     # save and load journal
     journal.save("experiments.jnl")
 
@@ -64,10 +76,12 @@ def analyse_journal(journal):
 
 import unittest
 import findspark
+
+
 class ExampleGaussianSparkTest(unittest.TestCase):
     def setUp(self):
         findspark.init()
-        
+
     def test_example(self):
         setup_backend()
         journal = infer_parameters()
@@ -76,9 +90,7 @@ def test_example(self):
         self.assertLess(abs(test_result - expected_result), 2.)
 
 
-if __name__  == "__main__":
+if __name__ == "__main__":
     setup_backend()
     journal = infer_parameters()
     analyse_journal(journal)
-
-    
diff --git a/examples/backends/dummy/pmcabc_gaussian.py b/examples/backends/dummy/pmcabc_gaussian.py
index 9ede5916..45016f69 100644
--- a/examples/backends/dummy/pmcabc_gaussian.py
+++ b/examples/backends/dummy/pmcabc_gaussian.py
@@ -1,26 +1,38 @@
 import numpy as np
 
+
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+                  172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+                  183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+                  197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+                  165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537,
+                  206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275,
+                  171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235,
+                  197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519,
+                  185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741,
+                  250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021,
+                  138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626,
+                  188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
     mu = Uniform([[150], [200]], )
     sigma = Uniform([[5], [25]], )
-    
+
     # define the model
     from abcpy.continuousmodels import Normal
     height = Normal([mu, sigma], )
-    
+
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
-    
+    statistics_calculator = Identity(degree=2, cross=False)
+
     # define distance
     from abcpy.distances import LogReg
     distance_calculator = LogReg(statistics_calculator)
-    
+
     # define kernel
     from abcpy.perturbationkernel import DefaultKernel
     kernel = DefaultKernel([mu, sigma])
@@ -29,16 +41,16 @@ def infer_parameters():
     # Note, the dummy backend does not parallelize the code!
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
-    
+
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -47,33 +59,36 @@ def analyse_journal(journal):
     # output parameters and weights
     journal.get_parameters()
     journal.get_weights()
-    
+
     # do post analysis
     journal.posterior_mean()
     journal.posterior_cov()
     journal.posterior_histogram()
-    
+
     # print configuration
     print(journal.configuration)
-    
+
     # save and load journal
     journal.save("experiments.jnl")
-    
+
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
     journal.plot_posterior_distr()
 
+
 # this code is for testing purposes only and not relevant to run the example
 import unittest
+
+
 class ExampleGaussianDummyTest(unittest.TestCase):
     def test_example(self):
         journal = infer_parameters()
         test_result = journal.posterior_mean()[0]
         expected_result = 176
         self.assertLess(abs(test_result - expected_result), 2.)
-    
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
diff --git a/examples/backends/mpi/mpi_model_inferences.py b/examples/backends/mpi/mpi_model_inferences.py
index 72cdaacd..e9dc1dd7 100644
--- a/examples/backends/mpi/mpi_model_inferences.py
+++ b/examples/backends/mpi/mpi_model_inferences.py
@@ -1,15 +1,18 @@
-#import logging
-#logging.basicConfig(level=logging.DEBUG)
+# import logging
+# logging.basicConfig(level=logging.DEBUG)
 
 import numpy as np
+
 from abcpy.probabilisticmodels import ProbabilisticModel, InputConnector
 
+
 def setup_backend():
     global backend
 
     from abcpy.backends import BackendMPI as Backend
     backend = Backend(process_per_model=2)
 
+
 class NestedBivariateGaussian(ProbabilisticModel):
     """
     This is a show case model of bi-variate Gaussian distribution where we assume
@@ -49,7 +52,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState, mpi_comm=
         if mpi_comm is None:
             ValueError('MPI-parallelized simulator model needs to have access \
             to a MPI communicator object')
-        #print("Start Forward Simulate on rank {}".format(mpi_comm.Get_rank()))
+        # print("Start Forward Simulate on rank {}".format(mpi_comm.Get_rank()))
         rank = mpi_comm.Get_rank()
         # Extract the input parameters
         mu = input_values[rank]
@@ -70,16 +73,17 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState, mpi_comm=
                 point = np.array([element0, element1])
                 result[i] = point
             result = [np.array([result[i]]).reshape(-1, ) for i in range(k)]
-            #print("End forward sim on master")
+            # print("End forward sim on master")
             return result
         else:
-            #print("End forward sim on workers")
+            # print("End forward sim on workers")
             return None
 
+
 def infer_parameters_pmcabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -91,7 +95,7 @@ def infer_parameters_pmcabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -105,14 +109,15 @@ def infer_parameters_pmcabc():
     eps_arr = np.array([10000])
     epsilon_percentile = 95
 
-    journal = sampler.sample([y_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
+
 def infer_parameters_abcsubsim():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -124,7 +129,7 @@ def infer_parameters_abcsubsim():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -138,10 +143,11 @@ def infer_parameters_abcsubsim():
 
     return journal
 
+
 def infer_parameters_rsmcabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -153,7 +159,7 @@ def infer_parameters_rsmcabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -165,14 +171,16 @@ def infer_parameters_rsmcabc():
     print('sampling')
     steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final = 2, 10, 1, 0.1, 10000, 500
     print('RSMCABC Inferring')
-    journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha , epsilon_init, epsilon_final,full_output=1)
+    journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final,
+                             full_output=1)
 
     return journal
 
+
 def infer_parameters_sabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -184,7 +192,7 @@ def infer_parameters_sabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -195,17 +203,19 @@ def infer_parameters_sabc():
     sampler = SABC([height_weight_model], [distance_calculator], backend, seed=1)
     print('sampling')
     steps, epsilon, n_samples, n_samples_per_param, beta, delta, v = 2, np.array([40000]), 10, 1, 2, 0.2, 0.3
-    ar_cutoff, resample, n_update, adaptcov, full_output  = 0.1, None, None, 1, 1
+    ar_cutoff, resample, n_update, adaptcov, full_output = 0.1, None, None, 1, 1
     #
     # # print('SABC Inferring')
-    journal = sampler.sample([y_obs], steps, epsilon, n_samples, n_samples_per_param, beta, delta, v, ar_cutoff, resample, n_update, adaptcov, full_output)
+    journal = sampler.sample([y_obs], steps, epsilon, n_samples, n_samples_per_param, beta, delta, v, ar_cutoff,
+                             resample, n_update, adaptcov, full_output)
 
     return journal
 
+
 def infer_parameters_apmcabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -217,7 +227,7 @@ def infer_parameters_apmcabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -227,14 +237,16 @@ def infer_parameters_apmcabc():
     from abcpy.inferences import APMCABC
     sampler = APMCABC([height_weight_model], [distance_calculator], backend, seed=1)
     steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 2, 100, 1, 0.2, 0.03, 2.0, 1, None
-    journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)
+    journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor,
+                             full_output, journal_file)
 
     return journal
 
+
 def infer_parameters_rejectionabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -246,7 +258,7 @@ def infer_parameters_rejectionabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -260,10 +272,11 @@ def infer_parameters_rejectionabc():
 
     return journal
 
+
 def infer_parameters_smcabc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -275,7 +288,7 @@ def infer_parameters_smcabc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -289,10 +302,11 @@ def infer_parameters_smcabc():
 
     return journal
 
+
 def infer_parameters_pmc():
     # define observation for true parameters mean=170, 65
     rng = np.random.RandomState()
-    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2,))]
+    y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -304,7 +318,7 @@ def infer_parameters_pmc():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     from abcpy.approx_lhd import SynLikelihood
     approx_lhd = SynLikelihood(statistics_calculator)
@@ -316,7 +330,7 @@ def infer_parameters_pmc():
     # sample from scheme
     T, n_sample, n_samples_per_param = 2, 10, 10
 
-    journal = sampler.sample([y_obs],  T, n_sample, n_samples_per_param)
+    journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param)
 
     return journal
 
@@ -324,6 +338,7 @@ def infer_parameters_pmc():
 def setUpModule():
     setup_backend()
 
+
 if __name__ == "__main__":
     setup_backend()
     print('True Value was: ' + str([170, 65]))
diff --git a/examples/backends/mpi/pmcabc_gaussian.py b/examples/backends/mpi/pmcabc_gaussian.py
index f7474f86..9d839c18 100644
--- a/examples/backends/mpi/pmcabc_gaussian.py
+++ b/examples/backends/mpi/pmcabc_gaussian.py
@@ -1,8 +1,9 @@
 import numpy as np
 
+
 def setup_backend():
     global backend
-    
+
     from abcpy.backends import BackendMPI as Backend
     backend = Backend()
     # The above line is equivalent to:
@@ -10,10 +11,20 @@ def setup_backend():
     # Notice: Models not parallelized by MPI should not be given process_per_model > 1
 
 
-
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
+             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
+             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
+             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
+             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
+             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
+             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
+             202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -26,7 +37,7 @@ def infer_parameters():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import Euclidean
@@ -35,12 +46,12 @@ def infer_parameters():
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, seed=1)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 2, 10, 1
     eps_arr = np.array([10000])
     epsilon_percentile = 95
-    journal = sampler.sample([y_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -49,15 +60,15 @@ def analyse_journal(journal):
     # output parameters and weights
     print(journal.parameters)
     print(journal.weights)
-    
+
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
     print(journal.posterior_histogram())
-    
+
     # print configuration
     print(journal.configuration)
-    
+
     # save and load journal
     journal.save("experiments.jnl")
 
@@ -67,6 +78,7 @@ def analyse_journal(journal):
 
 import unittest
 
+
 def setUpModule():
     '''
     If an exception is raised in a setUpModule then none of 
@@ -82,6 +94,7 @@ def setUpModule():
     '''
     setup_backend()
 
+
 class ExampleGaussianMPITest(unittest.TestCase):
     def test_example(self):
         journal = infer_parameters()
@@ -90,9 +103,7 @@ def test_example(self):
         self.assertLess(abs(test_result - expected_result), 2)
 
 
-if __name__  == "__main__":
+if __name__ == "__main__":
     setup_backend()
     journal = infer_parameters()
     analyse_journal(journal)
-
-    
diff --git a/examples/extensions/distances/default_distance.py b/examples/extensions/distances/default_distance.py
index 814e96fd..d80774c1 100644
--- a/examples/extensions/distances/default_distance.py
+++ b/examples/extensions/distances/default_distance.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from abcpy.distances import Distance, Euclidean
 
 
diff --git a/examples/extensions/models/gaussian_R/gaussian_model.R b/examples/extensions/models/gaussian_R/gaussian_model.R
index 7c67d69a..18c99414 100644
--- a/examples/extensions/models/gaussian_R/gaussian_model.R
+++ b/examples/extensions/models/gaussian_R/gaussian_model.R
@@ -1,4 +1,4 @@
-simple_gaussian <- function(mu, sigma, k = 1){
-	output <- rnorm(k, mu, sigma)
-	return(output)
+simple_gaussian <- function(mu, sigma, k = 1) {
+  output <- rnorm(k, mu, sigma)
+  return(output)
 }
\ No newline at end of file
diff --git a/examples/extensions/models/gaussian_R/gaussian_model.py b/examples/extensions/models/gaussian_R/gaussian_model.py
index 601dc4de..b281827d 100644
--- a/examples/extensions/models/gaussian_R/gaussian_model.py
+++ b/examples/extensions/models/gaussian_R/gaussian_model.py
@@ -1,10 +1,11 @@
-import numpy as np
-
 from numbers import Number
-from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
+import numpy as np
 import rpy2.robjects as robjects
 import rpy2.robjects.numpy2ri
+
+from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
+
 rpy2.robjects.numpy2ri.activate()
 
 robjects.r('''
@@ -13,6 +14,7 @@
 
 r_simple_gaussian = robjects.globalenv['simple_gaussian']
 
+
 class Gaussian(ProbabilisticModel, Continuous):
 
     def __init__(self, parameters, name='Gaussian'):
@@ -67,42 +69,54 @@ def pdf(self, input_values, x):
         sigma = input_values[1]
         pdf = np.norm(mu, sigma).pdf(x)
         return pdf
-    
+
+
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
+             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
+             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
+             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
+             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
+             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
+             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
+             202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continousmodels import Uniform
-    prior = Uniform([[150, 5],[200, 25]])
-    
+    prior = Uniform([[150, 5], [200, 25]])
+
     # define the model
     model = Gaussian([prior])
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
-    
+    statistics_calculator = Identity(degree=2, cross=False)
+
     # define distance
     from abcpy.distances import LogReg
     distance_calculator = LogReg(statistics_calculator)
-    
+
     # define backend
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
-    
+
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([model], distance_calculator, backend)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
-    
+
 
 def analyse_journal(journal):
     # output parameters and weights
@@ -113,16 +127,17 @@ def analyse_journal(journal):
     print(journal.posterior_mean())
     print(journal.posterior_cov())
     print(journal.posterior_histogram())
-    
+
     # print configuration
     print(journal.configuration)
 
     # save and load journal
     journal.save("experiments.jnl")
-    
+
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
diff --git a/examples/extensions/models/gaussian_R/graph_ABC.py b/examples/extensions/models/gaussian_R/graph_ABC.py
index 122c6bbf..15bcae9b 100644
--- a/examples/extensions/models/gaussian_R/graph_ABC.py
+++ b/examples/extensions/models/gaussian_R/graph_ABC.py
@@ -1,31 +1,28 @@
-
 import matplotlib.pyplot as plt
-from scipy.stats import gaussian_kde
 import numpy as np
-
-def plot(samples, path = None, true_value = 5, title = 'ABC posterior'): 
-	Bayes_estimate = np.mean(samples, axis = 0)
-	theta = true_value
-	xmin, xmax = max(samples[:,0]), min(samples[:,0])
-	positions = np.linspace(xmin, xmax, samples.shape[0])
-	gaussian_kernel = gaussian_kde(samples[:,0].reshape(samples.shape[0],))
-	values = gaussian_kernel(positions)
-	plt.figure()
-	plt.plot(positions,gaussian_kernel(positions))
-	plt.plot([theta, theta],[min(values), max(values)+.1*(max(values)-min(values))])
-	plt.plot([Bayes_estimate, Bayes_estimate],[min(values), max(values)+.1*(max(values)-min(values))])
-	plt.ylim([min(values), max(values)+.1*(max(values)-min(values))])
-	plt.xlabel(r'$\theta$')
-	plt.ylabel('density')
-	#plt.xlim([0,1])
-	plt.rc('axes', labelsize=15) 
-	plt.legend(loc='best', frameon=False, numpoints=1)
-	font = {'size'   : 15}
-	plt.rc('font', **font)
-	plt.title(title)
-	if path is not None :
-		plt.savefig(path)
-	return plt
-
+from scipy.stats import gaussian_kde
 
 
+def plot(samples, path=None, true_value=5, title='ABC posterior'):
+    Bayes_estimate = np.mean(samples, axis=0)
+    theta = true_value
+    xmin, xmax = max(samples[:, 0]), min(samples[:, 0])
+    positions = np.linspace(xmin, xmax, samples.shape[0])
+    gaussian_kernel = gaussian_kde(samples[:, 0].reshape(samples.shape[0], ))
+    values = gaussian_kernel(positions)
+    plt.figure()
+    plt.plot(positions, gaussian_kernel(positions))
+    plt.plot([theta, theta], [min(values), max(values) + .1 * (max(values) - min(values))])
+    plt.plot([Bayes_estimate, Bayes_estimate], [min(values), max(values) + .1 * (max(values) - min(values))])
+    plt.ylim([min(values), max(values) + .1 * (max(values) - min(values))])
+    plt.xlabel(r'$\theta$')
+    plt.ylabel('density')
+    # plt.xlim([0,1])
+    plt.rc('axes', labelsize=15)
+    plt.legend(loc='best', frameon=False, numpoints=1)
+    font = {'size': 15}
+    plt.rc('font', **font)
+    plt.title(title)
+    if path is not None:
+        plt.savefig(path)
+    return plt
diff --git a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
index 20265010..00840b1c 100644
--- a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
@@ -1,8 +1,10 @@
+from numbers import Number
+
 import numpy as np
+from gaussian_model_simple import gaussian_model
 
-from numbers import Number
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
-from gaussian_model_simple import gaussian_model
+
 
 class Gaussian(ProbabilisticModel, Continuous):
 
@@ -59,74 +61,86 @@ def pdf(self, input_values, x):
         pdf = np.norm(mu, sigma).pdf(x)
         return pdf
 
+
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
+             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
+             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
+             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
+             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
+             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
+             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
+             202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
     prior = Uniform([[150, 5], [200, 25]], )
-    
+
     # define the model
     model = Gaussian([prior], )
-    
+
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
-    
+    statistics_calculator = Identity(degree=2, cross=False)
+
     # define distance
     from abcpy.distances import LogReg
     distance_calculator = LogReg(statistics_calculator)
-    
+
     # define backend
-    from abcpy.backends import BackendSpark as Backend
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
-    
+
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([model], [distance_calculator], backend)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 100, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
-    
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+
     return journal
-    
+
 
 def analyse_journal(journal):
     # output parameters and weights
     print(journal.parameters)
     print(journal.weights)
-    
+
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
     print(journal.posterior_histogram())
-    
+
     # print configuration
     print(journal.configuration)
-    
+
     # save and load journal
     journal.save("experiments.jnl")
-    
+
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
-    
+
 
 # this code is for testing purposes only and not relevant to run the example
 import unittest
+
+
 class ExampleExtendModelGaussianCpp(unittest.TestCase):
     def test_example(self):
         journal = infer_parameters()
         test_result = journal.posterior_mean()[0]
         expected_result = 177.02
         self.assertLess(abs(test_result - expected_result), 1.)
-    
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
-    
diff --git a/examples/extensions/models/gaussian_f90/gaussian_model_simple.f90 b/examples/extensions/models/gaussian_f90/gaussian_model_simple.f90
index b9054dca..8ae17901 100644
--- a/examples/extensions/models/gaussian_f90/gaussian_model_simple.f90
+++ b/examples/extensions/models/gaussian_f90/gaussian_model_simple.f90
@@ -1,49 +1,49 @@
 module gaussian_model
 contains
-  subroutine gaussian(output, mu, sigma, k, seed)
-    integer, intent(in) :: k, seed
-    real(8), intent(in) :: mu, sigma
-    real(8), intent(out) :: output(k)
-
-    integer :: i, n
-    real(8) :: r, theta
-    real(8), dimension(:), allocatable :: temp
-    integer(4), dimension(:), allocatable :: seed_arr
-
-    ! get random seed array size and fill seed_arr with provided seed
-    call random_seed(size = n)
-    allocate(seed_arr(n))
-    seed_arr = seed
-    call random_seed(put = seed_arr)
-
-    ! create 2k random numbers uniformly from [0,1]
-    if(allocated(temp)) then
-       deallocate(temp)
-    end if
-    allocate(temp(k*2))
-    call random_number(temp)
-
-    ! Use Box-Muller transfrom to create normally distributed variables
-    do i = 1, k
-       r = (-2.0 * log(temp(2*i-1)))**0.5
-       theta = 2 * 3.1415926 * temp(2*i)
-       output(i) = mu + sigma * r * sin(theta)
-    end do
-  end subroutine gaussian
+    subroutine gaussian(output, mu, sigma, k, seed)
+        integer, intent(in) :: k, seed
+        real(8), intent(in) :: mu, sigma
+        real(8), intent(out) :: output(k)
+
+        integer :: i, n
+        real(8) :: r, theta
+        real(8), dimension(:), allocatable :: temp
+        integer(4), dimension(:), allocatable :: seed_arr
+
+        ! get random seed array size and fill seed_arr with provided seed
+        call random_seed(size = n)
+        allocate(seed_arr(n))
+        seed_arr = seed
+        call random_seed(put = seed_arr)
+
+        ! create 2k random numbers uniformly from [0,1]
+        if(allocated(temp)) then
+            deallocate(temp)
+        end if
+        allocate(temp(k * 2))
+        call random_number(temp)
+
+        ! Use Box-Muller transfrom to create normally distributed variables
+        do i = 1, k
+            r = (-2.0 * log(temp(2 * i - 1)))**0.5
+            theta = 2 * 3.1415926 * temp(2 * i)
+            output(i) = mu + sigma * r * sin(theta)
+        end do
+    end subroutine gaussian
 end module gaussian_model
 
 program main
-  use gaussian_model
-  implicit none
-
-  integer, parameter :: k = 100
-  integer :: seed = 9, i
-  real(8) :: mu = 10.0, sigma = 2.0
-  real(8) :: output(k)
-
-  call gaussian(output, mu, sigma, k, seed)
-  
-  do i = 1, k
-     write(*,*) output(i)
-  end do
+    use gaussian_model
+    implicit none
+
+    integer, parameter :: k = 100
+    integer :: seed = 9, i
+    real(8) :: mu = 10.0, sigma = 2.0
+    real(8) :: output(k)
+
+    call gaussian(output, mu, sigma, k, seed)
+
+    do i = 1, k
+        write(*, *) output(i)
+    end do
 end program main
diff --git a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
index 0a2527fe..5e57d7ba 100644
--- a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
@@ -3,12 +3,12 @@
 from abcpy.models import Model
 from gaussian_model_simple import gaussian_model
 
+
 class Gaussian(Model):
     def __init__(self, prior, seed=None):
         self.prior = prior
         self.sample_from_prior()
         self.rng = np.random.RandomState(seed)
-        
 
     def set_parameters(self, theta):
         theta = np.array(theta)
@@ -23,88 +23,99 @@ def get_parameters(self):
         return np.array([self.mu, self.sigma])
 
     def sample_from_prior(self):
-        sample = self.prior.sample(1).reshape(-1)
+        sample = self.prior.sample(1, ).reshape(-1)
         self.set_parameters(sample)
 
     def simulate(self, k):
         seed = self.rng.randint(np.iinfo(np.int32).max)
         result = gaussian_model(self.mu, self.sigma, k, seed)
         return list(result)
-	    
-    
+
+
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
+             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
+             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
+             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
+             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
+             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
+             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
+             202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.distributions import Uniform
-    prior = Uniform([150, 5],[200, 25])
-    
+    prior = Uniform([150, 5], [200, 25])
+
     # define the model
     model = Gaussian(prior)
-    
+
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
-    
+    statistics_calculator = Identity(degree=2, cross=False)
+
     # define distance
     from abcpy.distances import LogReg
     distance_calculator = LogReg(statistics_calculator)
-    
+
     # define kernel
     from abcpy.distributions import MultiStudentT
     mean, cov, df = np.array([.0, .0]), np.eye(2), 3.
     kernel = MultiStudentT(mean, cov, df)
-    
+
     # define backend
-    from abcpy.backends import BackendSpark as Backend
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
-    
+
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC(model, distance_calculator, kernel, backend)
-    
+
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 100, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample(y_obs,  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
-    
+    journal = sampler.sample(y_obs, T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+
     return journal
-    
+
 
 def analyse_journal(journal):
     # output parameters and weights
     print(journal.parameters)
     print(journal.weights)
-    
+
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
     print(journal.posterior_histogram())
-    
+
     # print configuration
     print(journal.configuration)
-    
+
     # save and load journal
     journal.save("experiments.jnl")
-    
+
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
-    
+
 
 # this code is for testing purposes only and not relevant to run the example
 import unittest
+
+
 class ExampleExtendModelGaussianCpp(unittest.TestCase):
     def test_example(self):
         journal = infer_parameters()
         test_result = journal.posterior_mean()[0]
         expected_result = 177.02
         self.assertLess(abs(test_result - expected_result), 1.)
-    
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
-    
diff --git a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
index b186c9a9..7ce44e16 100644
--- a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
@@ -1,12 +1,13 @@
 import logging
-import numpy as np
-
 from numbers import Number
 
+import numpy as np
+
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
 logging.basicConfig(level=logging.INFO)
 
+
 class Gaussian(ProbabilisticModel, Continuous):
     """
     This class is an re-implementation of the `abcpy.continousmodels.Normal` for documentation purposes.
@@ -23,7 +24,6 @@ def __init__(self, parameters, name='Gaussian'):
         input_connector = InputConnector.from_list(parameters)
         super().__init__(input_connector, name)
 
-
     def _check_input(self, input_values):
         # Check whether input has correct type or format
         if len(input_values) != 2:
@@ -37,7 +37,6 @@ def _check_input(self, input_values):
 
         return True
 
-
     def _check_output(self, values):
         if not isinstance(values, Number):
             raise ValueError('Output of the normal distribution is always a number.')
@@ -45,11 +44,9 @@ def _check_output(self, values):
         # At this point values is a number (int, float); full domain for Normal is allowed
         return True
 
-
     def get_output_dimension(self):
         return 1
 
-
     def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
         # Extract the input parameters
         mu = input_values[0]
@@ -62,17 +59,27 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
         result = [np.array([x]) for x in vector_of_k_samples]
         return result
 
-
     def pdf(self, input_values, x):
         mu = input_values[0]
         sigma = input_values[1]
-        pdf = np.norm(mu,sigma).pdf(x)
+        pdf = np.norm(mu, sigma).pdf(x)
         return pdf
 
 
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+                  172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+                  183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+                  197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+                  165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537,
+                  206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275,
+                  171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235,
+                  197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519,
+                  185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741,
+                  250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021,
+                  138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626,
+                  188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
     # define prior
     from abcpy.continuousmodels import Uniform
     mu = Uniform([[150], [200]], )
@@ -83,7 +90,7 @@ def infer_parameters():
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
     from abcpy.distances import LogReg
@@ -106,7 +113,7 @@ def infer_parameters():
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -133,6 +140,8 @@ def analyse_journal(journal):
 
 # this code is for testing purposes only and not relevant to run the example
 import unittest
+
+
 class ExampleExtendModelGaussianPython(unittest.TestCase):
     def test_example(self):
         journal = infer_parameters()
@@ -141,7 +150,6 @@ def test_example(self):
         self.assertLess(abs(test_result - expected_result), 2.)
 
 
-if __name__  == "__main__":
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
-    
diff --git a/examples/extensions/perturbationkernels/multivariate_normal_kernel.py b/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
index 70c2c67b..1eb970fc 100644
--- a/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
+++ b/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
@@ -1,9 +1,12 @@
-from abcpy.perturbationkernel import PerturbationKernel, ContinuousKernel
 import numpy as np
 from scipy.stats import multivariate_normal
 
+from abcpy.perturbationkernel import PerturbationKernel, ContinuousKernel
+
+
 class MultivariateNormalKernel(PerturbationKernel, ContinuousKernel):
     """This class defines a kernel perturbing the parameters using a multivariate normal distribution."""
+
     def __init__(self, models):
         self.models = models
 
@@ -22,9 +25,10 @@ def calculate_cov(self, accepted_parameters_manager, kernel_index):
         list
             The covariance matrix corresponding to this kernel.
         """
-        if(accepted_parameters_manager.accepted_weights_bds is not None):
+        if accepted_parameters_manager.accepted_weights_bds is not None:
             weights = accepted_parameters_manager.accepted_weights_bds.value()
-            cov = np.cov(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index], aweights=weights.reshape(-1), rowvar=False)
+            cov = np.cov(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index],
+                         aweights=weights.reshape(-1), rowvar=False)
         else:
             cov = np.cov(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index], rowvar=False)
         return cov
@@ -84,4 +88,4 @@ def pdf(self, accepted_parameters_manager, kernel_index, row_index, x):
 
         cov = accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]
 
-        return multivariate_normal(mean, cov).pdf(x)
\ No newline at end of file
+        return multivariate_normal(mean, cov).pdf(x)
diff --git a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
index 6bfb0be7..939fa261 100644
--- a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
+++ b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
@@ -1,37 +1,65 @@
 import numpy as np
+
+
 def infer_parameters():
     # The data corresponding to model_1 defined below
-    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368, 4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294, 3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705, 3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419, 4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124, 4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361, 4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868, 4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221, 4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768, 4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518, 4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284, 4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087, 4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748, 3.8668863066511303, 3.8837108501541007]
+    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
+                  4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
+                  3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705,
+                  3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419,
+                  4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124,
+                  4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361,
+                  4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868,
+                  4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221,
+                  4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768,
+                  4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518,
+                  4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284,
+                  4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087,
+                  4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748,
+                  3.8668863066511303, 3.8837108501541007]
 
     # The prior information changing the class size and the teacher student ratio, depending on the yearly budget of the school 
     from abcpy.continuousmodels import Uniform, Normal
-    school_budget = Uniform([[1], [10]], name = 'school_budget')
+    school_budget = Uniform([[1], [10]], name='school_budget')
 
     # The average class size of a certain school
-    class_size = Normal([[800*school_budget], [1]], name = 'class_size')
+    class_size = Normal([[800 * school_budget], [1]], name='class_size')
 
     # The number of teachers in the school
-    no_teacher = Normal([[20*school_budget], [1]], name = 'no_teacher')
+    no_teacher = Normal([[20 * school_budget], [1]], name='no_teacher')
 
     # The grade a student would receive without any bias
-    grade_without_additional_effects = Normal([[4.5], [0.25]], name = 'grade_without_additional_effects')
+    grade_without_additional_effects = Normal([[4.5], [0.25]], name='grade_without_additional_effects')
 
     # The grade a student of a certain school receives
     final_grade = grade_without_additional_effects - .001 * class_size + .02 * no_teacher
 
     # The data corresponding to model_2 defined below
-    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192, 3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992, 2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971, 2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507, 3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989, 2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755, 2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858, 2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202, 2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186, 3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073, 2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045, 3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465, 2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546, 1.0893224045062178, 0.8032302688764734, 2.868438615047827]
+    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192,
+                       3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992,
+                       2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971,
+                       2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507,
+                       3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989,
+                       2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755,
+                       2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858,
+                       2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202,
+                       2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186,
+                       3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073,
+                       2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045,
+                       3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465,
+                       2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546,
+                       1.0893224045062178, 0.8032302688764734, 2.868438615047827]
 
     # A quantity that determines whether a student will receive a scholarship
-    scholarship_without_additional_effects = Normal([[2], [0.5]], name = 'schol_without_additional_effects')
+    scholarship_without_additional_effects = Normal([[2], [0.5]], name='schol_without_additional_effects')
 
     # A quantity determining whether a student receives a scholarship, including his social teacher_student_ratio
     final_scholarship = scholarship_without_additional_effects + .03 * no_teacher
 
     # Define a summary statistics for final grade and final scholarship
     from abcpy.statistics import Identity
-    statistics_calculator_final_grade = Identity(degree = 2, cross = False)
-    statistics_calculator_final_scholarship = Identity(degree = 3, cross = False)
+    statistics_calculator_final_grade = Identity(degree=2, cross=False)
+    statistics_calculator_final_scholarship = Identity(degree=3, cross=False)
 
     # Define a distance measure for final grade and final scholarship
     from abcpy.distances import Euclidean
@@ -44,15 +72,14 @@ def infer_parameters():
 
     # Define kernels
     from abcpy.perturbationkernel import MultivariateNormalKernel, MultivariateStudentTKernel
-    kernel_1 = MultivariateNormalKernel([school_budget,\ 
-                scholarship_without_additional_effects, grade_without_additional_effects])
+    kernel_1 = MultivariateNormalKernel([school_budget, \
+                                         scholarship_without_additional_effects, grade_without_additional_effects])
     kernel_2 = MultivariateStudentTKernel([class_size, no_teacher], df=3)
 
     # Join the defined kernels
     from abcpy.perturbationkernel import JointPerturbationKernel
     kernel = JointPerturbationKernel([kernel_1, kernel_2])
 
-
     # Define sampling parameters
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
@@ -63,7 +90,8 @@ def infer_parameters():
     sampler = PMCABC([final_grade, final_scholarship], [distance_calculator, distance_calculator], backend, kernel)
 
     # Sample
-    journal = sampler.sample([y_obs_grades, y_obs_scholarship], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs_grades, y_obs_scholarship], T, eps_arr, n_sample, n_samples_per_param,
+                             epsilon_percentile)
 
 
 def analyse_journal(journal):
@@ -85,7 +113,7 @@ def analyse_journal(journal):
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
-
diff --git a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
index 8e65ecbe..628b6071 100644
--- a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
+++ b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
@@ -1,39 +1,67 @@
 import numpy as np
 
 """An example showing how to implement a bayesian network in ABCpy"""
+
+
 def infer_parameters():
     # The data corresponding to model_1 defined below
-    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368, 4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294, 3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705, 3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419, 4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124, 4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361, 4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868, 4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221, 4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768, 4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518, 4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284, 4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087, 4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748, 3.8668863066511303, 3.8837108501541007]
+    grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
+                  4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
+                  3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705,
+                  3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419,
+                  4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124,
+                  4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361,
+                  4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868,
+                  4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221,
+                  4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768,
+                  4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518,
+                  4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284,
+                  4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087,
+                  4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748,
+                  3.8668863066511303, 3.8837108501541007]
 
     # The prior information changing the class size and the teacher student ratio, depending on the yearly budget of the school 
     from abcpy.continuousmodels import Uniform, Normal
-    school_budget = Uniform([[1], [10]], name = 'school_budget')
+    school_budget = Uniform([[1], [10]], name='school_budget')
 
     # The average class size of a certain school
-    class_size = Normal([[800*school_budget], [1]], name = 'class_size')
+    class_size = Normal([[800 * school_budget], [1]], name='class_size')
 
     # The number of teachers in the school
-    no_teacher = Normal([[20*school_budget], [1]], name = 'no_teacher')
+    no_teacher = Normal([[20 * school_budget], [1]], name='no_teacher')
 
     # The grade a student would receive without any bias
-    grade_without_additional_effects = Normal([[4.5], [0.25]], name = 'grade_without_additional_effects')
+    grade_without_additional_effects = Normal([[4.5], [0.25]], name='grade_without_additional_effects')
 
     # The grade a student of a certain school receives
     final_grade = grade_without_additional_effects - .001 * class_size + .02 * no_teacher
 
     # The data corresponding to model_2 defined below
-    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192, 3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992, 2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971, 2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507, 3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989, 2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755, 2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858, 2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202, 2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186, 3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073, 2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045, 3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465, 2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546, 1.0893224045062178, 0.8032302688764734, 2.868438615047827]
+    scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192,
+                       3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992,
+                       2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971,
+                       2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507,
+                       3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989,
+                       2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755,
+                       2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858,
+                       2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202,
+                       2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186,
+                       3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073,
+                       2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045,
+                       3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465,
+                       2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546,
+                       1.0893224045062178, 0.8032302688764734, 2.868438615047827]
 
     # A quantity that determines whether a student will receive a scholarship
-    scholarship_without_additional_effects = Normal([[2], [0.5]], name = 'schol_without_additional_effects')
+    scholarship_without_additional_effects = Normal([[2], [0.5]], name='schol_without_additional_effects')
 
     # A quantity determining whether a student receives a scholarship, including his social teacher_student_ratio
     final_scholarship = scholarship_without_additional_effects + .03 * no_teacher
 
     # Define a summary statistics for final grade and final scholarship
     from abcpy.statistics import Identity
-    statistics_calculator_final_grade = Identity(degree = 2, cross = False)
-    statistics_calculator_final_scholarship = Identity(degree = 3, cross = False)
+    statistics_calculator_final_grade = Identity(degree=2, cross=False)
+    statistics_calculator_final_scholarship = Identity(degree=3, cross=False)
 
     # Define a distance measure for final grade and final scholarship
     from abcpy.distances import Euclidean
@@ -83,6 +111,7 @@ def analyse_journal(journal):
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
-if __name__  == "__main__":
+
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
diff --git a/examples/modelselection/randomforest_modelselections.py b/examples/modelselection/randomforest_modelselections.py
index 8640b651..b66a76d8 100644
--- a/examples/modelselection/randomforest_modelselections.py
+++ b/examples/modelselection/randomforest_modelselections.py
@@ -1,36 +1,37 @@
 from abcpy.modelselections import RandomForest
 
+
 def infer_model():
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176]
 
     ## Create a array of models
     from abcpy.continuousmodels import Uniform, Normal, StudentT
-    model_array = [None]*2
+    model_array = [None] * 2
 
-    #Model 1: Gaussian
+    # Model 1: Gaussian
     mu1 = Uniform([[150], [200]], name='mu1')
     sigma1 = Uniform([[5.0], [25.0]], name='sigma1')
     model_array[0] = Normal([mu1, sigma1])
-    
-    #Model 2: Student t
+
+    # Model 2: Student t
     mu2 = Uniform([[150], [200]], name='mu2')
     sigma2 = Uniform([[1], [30.0]], name='sigma2')
     model_array[1] = StudentT([mu2, sigma2])
 
     # define statistics
     from abcpy.statistics import Identity
-    statistics_calculator = Identity(degree = 2, cross = False)
+    statistics_calculator = Identity(degree=2, cross=False)
 
     # define backend
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
 
     # Initiate the Model selection scheme
-    modelselection = RandomForest(model_array, statistics_calculator, backend, seed = 1)
+    modelselection = RandomForest(model_array, statistics_calculator, backend, seed=1)
 
     # Choose the correct model
-    model = modelselection.select_model(y_obs, n_samples = 100, n_samples_per_param = 1)
+    model = modelselection.select_model(y_obs, n_samples=100, n_samples_per_param=1)
 
     # Compute the posterior probability of each of the models
     model_prob = modelselection.posterior_probability(y_obs)
diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
index cd77da3b..99983a91 100644
--- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
+++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
@@ -1,5 +1,6 @@
 import numpy as np
 
+
 def infer_parameters():
     # define backend
     # Note, the dummy backend does not parallelize the code!
@@ -7,7 +8,18 @@ def infer_parameters():
     backend = Backend()
 
     # define observation for true parameters mean=170, std=15
-    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
+    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+                  172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+                  183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+                  197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+                  165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537,
+                  206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275,
+                  171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235,
+                  197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519,
+                  185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741,
+                  250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021,
+                  138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626,
+                  188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -30,7 +42,6 @@ def infer_parameters():
     # Redefine the statistics function
     new_statistics_calculator = statistics_learning.get_statistics()
 
-
     # Learn the optimal summary statistics using SemiautomaticNN summary selection;
     # we use 200 samples as a validation set for early stopping:
     from abcpy.statisticslearning import SemiautomaticNN
@@ -41,7 +52,6 @@ def infer_parameters():
     # Redefine the statistics function
     new_statistics_calculator = statistics_learning.get_statistics()
 
-
     # define distance
     from abcpy.distances import Euclidean
     distance_calculator = Euclidean(new_statistics_calculator)
@@ -58,7 +68,7 @@ def infer_parameters():
     T, n_sample, n_samples_per_param = 3, 10, 10
     eps_arr = np.array([500])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs],  T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -84,6 +94,6 @@ def analyse_journal(journal):
 
 
 # this code is for testing purposes only and not relevant to run the exampl
-if __name__  == "__main__":
+if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)
diff --git a/tests/acceptedparametersmanager_tests.py b/tests/acceptedparametersmanager_tests.py
index e3eb14c5..19c9d964 100644
--- a/tests/acceptedparametersmanager_tests.py
+++ b/tests/acceptedparametersmanager_tests.py
@@ -1,54 +1,59 @@
 import unittest
-from abcpy.continuousmodels import Normal
-from abcpy.discretemodels import Binomial
+
 from abcpy.acceptedparametersmanager import *
 from abcpy.backends import BackendDummy as Backend
+from abcpy.continuousmodels import Normal
+from abcpy.discretemodels import Binomial
 
 """Tests whether the methods defined for AcceptedParametersManager work as intended."""
 
 
 class BroadcastTests(unittest.TestCase):
     """Tests whether observations can be broadcasted using broadcast."""
+
     def test(self):
         model = Normal([1, 0.1])
         Manager = AcceptedParametersManager([model])
         backend = Backend()
-        Manager.broadcast(backend, [1,2,3])
-        self.assertEqual(Manager.observations_bds.value(), [1,2,3])
+        Manager.broadcast(backend, [1, 2, 3])
+        self.assertEqual(Manager.observations_bds.value(), [1, 2, 3])
 
 
 class UpdateKernelValuesTests(unittest.TestCase):
     """Tests whether kernel_parameters_bds can be updated."""
+
     def test(self):
         model = Normal([1, 0.1])
         Manager = AcceptedParametersManager([model])
         backend = Backend()
         Manager.update_kernel_values(backend, [1])
-        self.assertEqual(Manager.kernel_parameters_bds.value(),[1])
+        self.assertEqual(Manager.kernel_parameters_bds.value(), [1])
 
 
 class UpdateBroadcastTests(unittest.TestCase):
     """Tests whether it is possible to update accepted_parameters_bds, accepted_weights_bds and accepted_cov_mats_bds through update_broadcast."""
+
     def setUp(self):
         self.model = Normal([1, 0.1])
         self.backend = Backend()
         self.Manager = AcceptedParametersManager([self.model])
 
     def test_accepted_parameters(self):
-        self.Manager.update_broadcast(self.backend, [1,2,3])
-        self.assertEqual(self.Manager.accepted_parameters_bds.value(),[1,2,3])
+        self.Manager.update_broadcast(self.backend, [1, 2, 3])
+        self.assertEqual(self.Manager.accepted_parameters_bds.value(), [1, 2, 3])
 
     def test_accepted_weights(self):
-        self.Manager.update_broadcast(self.backend, accepted_weights=[1,2,3])
-        self.assertEqual(self.Manager.accepted_weights_bds.value(),[1,2,3])
+        self.Manager.update_broadcast(self.backend, accepted_weights=[1, 2, 3])
+        self.assertEqual(self.Manager.accepted_weights_bds.value(), [1, 2, 3])
 
     def test_accepted_cov_matsrix(self):
-        self.Manager.update_broadcast(self.backend, accepted_cov_mats=[[1,0],[0,1]])
-        self.assertEqual(self.Manager.accepted_cov_mats_bds.value(), [[1,0],[0,1]])
+        self.Manager.update_broadcast(self.backend, accepted_cov_mats=[[1, 0], [0, 1]])
+        self.assertEqual(self.Manager.accepted_cov_mats_bds.value(), [[1, 0], [0, 1]])
 
 
 class GetMappingTests(unittest.TestCase):
     """Tests whether the dfs mapping returned from get_mapping is in the correct order."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
@@ -58,11 +63,12 @@ def test(self):
         Manager = AcceptedParametersManager([graph])
 
         mapping, mapping_index = Manager.get_mapping([graph])
-        self.assertEqual(mapping, [(B1,0),(N2,1),(N1,2)])
+        self.assertEqual(mapping, [(B1, 0), (N2, 1), (N1, 2)])
 
 
 class GetAcceptedParametersBdsValuesTests(unittest.TestCase):
     """Tests whether get_accepted_parameters_bds_values returns the correct values."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
@@ -71,13 +77,13 @@ def test(self):
 
         Manager = AcceptedParametersManager([graph])
         backend = Backend()
-        Manager.update_broadcast(backend, [[2,3,4],[0.27,0.32,0.28],[0.97,0.12,0.99]])
+        Manager.update_broadcast(backend, [[2, 3, 4], [0.27, 0.32, 0.28], [0.97, 0.12, 0.99]])
 
-        values = Manager.get_accepted_parameters_bds_values([B1,N2,N1])
-        values_expected = [np.array(x).reshape(-1,) for x in [[2,3,4],[0.27,0.32,0.28],[0.97,0.12,0.99]]]
+        values = Manager.get_accepted_parameters_bds_values([B1, N2, N1])
+        values_expected = [np.array(x).reshape(-1, ) for x in [[2, 3, 4], [0.27, 0.32, 0.28], [0.97, 0.12, 0.99]]]
 
         self.assertTrue(all([all(a == b) for a, b in zip(values, values_expected)]))
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index bde51a7c..f9d9b8f6 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -1,26 +1,28 @@
 import unittest
+
 import numpy as np
 
+from abcpy.approx_lhd import PenLogReg, SynLikelihood
 from abcpy.continuousmodels import Normal
 from abcpy.continuousmodels import Uniform
 from abcpy.statistics import Identity
-from abcpy.approx_lhd import PenLogReg, SynLikelihood
+
 
 class PenLogRegTests(unittest.TestCase):
     def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')
         self.sigma = Uniform([[5.0], [10.0]], name='sigma')
-        self.model = Normal([self.mu,self.sigma])
+        self.model = Normal([self.mu, self.sigma])
         self.model_bivariate = Uniform([[0, 0], [1, 1]], name="model")
-        self.stat_calc = Identity(degree = 2, cross = 1)
-        self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate = 100, n_folds = 10, max_iter = 100000, seed = 1)
-        self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate = 100, n_folds = 10, max_iter = 100000, seed = 1)
+        self.stat_calc = Identity(degree=2, cross=1)
+        self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate=100, n_folds=10, max_iter=100000, seed=1)
+        self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10,
+                                          max_iter=100000, seed=1)
 
     def test_likelihood(self):
-
-        #Checks whether wrong input type produces error message
-        self.assertRaises(TypeError, self.likfun.likelihood, 3.4, [2,1])
-        self.assertRaises(TypeError, self.likfun.likelihood, [2,4], 3.4)
+        # Checks whether wrong input type produces error message
+        self.assertRaises(TypeError, self.likfun.likelihood, 3.4, [2, 1])
+        self.assertRaises(TypeError, self.likfun.likelihood, [2, 4], 3.4)
 
         # create observed data
         y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))
@@ -45,21 +47,19 @@ def test_likelihood(self):
         self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
 
 
-
 class SynLikelihoodTests(unittest.TestCase):
     def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')
         self.sigma = Uniform([[5.0], [10.0]], name='sigma')
-        self.model = Normal([self.mu,self.sigma])
-        self.stat_calc = Identity(degree = 2, cross = 0)
+        self.model = Normal([self.mu, self.sigma])
+        self.stat_calc = Identity(degree=2, cross=0)
         self.likfun = SynLikelihood(self.stat_calc)
 
-
     def test_likelihood(self):
-        #Checks whether wrong input type produces error message
-        self.assertRaises(TypeError, self.likfun.likelihood, 3.4, [2,1])
-        self.assertRaises(TypeError, self.likfun.likelihood, [2,4], 3.4)
-               
+        # Checks whether wrong input type produces error message
+        self.assertRaises(TypeError, self.likfun.likelihood, 3.4, [2, 1])
+        self.assertRaises(TypeError, self.likfun.likelihood, [2, 4], 3.4)
+
         # create observed data
         y_obs = [9.8]
         # create fake simulated data
@@ -74,4 +74,3 @@ def test_likelihood(self):
 
 if __name__ == '__main__':
     unittest.main()
-        
diff --git a/tests/backend_tests_mpi.py b/tests/backend_tests_mpi.py
index d0b81e9d..cdb3b7ef 100644
--- a/tests/backend_tests_mpi.py
+++ b/tests/backend_tests_mpi.py
@@ -18,46 +18,46 @@ def setUpModule():
     for the team and we now only need to write unit-tests from the scheduler's 
     point of view. 
     '''
-    global rank,backend_mpi
+    global rank, backend_mpi
     comm = MPI.COMM_WORLD
     rank = comm.Get_rank()
     backend_mpi = BackendMPI()
 
+
 class MPIBackendTests(unittest.TestCase):
 
     def test_parallelize(self):
-        data = [0]*backend_mpi.size()
+        data = [0] * backend_mpi.size()
         pds = backend_mpi.parallelize(data)
         pds_map = backend_mpi.map(lambda x: x + MPI.COMM_WORLD.Get_rank(), pds)
         res = backend_mpi.collect(pds_map)
 
         for scheduler_index in backend_mpi.scheduler_node_ranks():
-            self.assertTrue(scheduler_index not in res,"Node in scheduler_node_ranks performed map.")
+            self.assertTrue(scheduler_index not in res, "Node in scheduler_node_ranks performed map.")
 
     def test_map(self):
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
-        pds_map = backend_mpi.map(lambda x:x**2,pds)
+        pds_map = backend_mpi.map(lambda x: x ** 2, pds)
         res = backend_mpi.collect(pds_map)
-        assert res==list(map(lambda x:x**2,data))
-
+        assert res == list(map(lambda x: x ** 2, data))
 
     def test_broadcast(self):
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
 
         bds = backend_mpi.broadcast(100)
 
-        #Pollute the BDS values of the scheduler to confirm teams
+        # Pollute the BDS values of the scheduler to confirm teams
         # use their broadcasted value
-        for k,v in  backend_mpi.bds_store.items():
-             backend_mpi.bds_store[k] = 99999
+        for k, v in backend_mpi.bds_store.items():
+            backend_mpi.bds_store[k] = 99999
 
         def test_map(x):
             return x + bds.value()
 
         pds_m = backend_mpi.map(test_map, pds)
-        self.assertTrue(backend_mpi.collect(pds_m)==[101,102,103,104,105])
+        self.assertTrue(backend_mpi.collect(pds_m) == [101, 102, 103, 104, 105])
 
     def test_pds_delete(self):
 
@@ -65,79 +65,73 @@ def check_if_exists(x):
             obj = BackendMPITestHelper()
             return obj.check_pds(x)
 
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
 
-        #Check if the pds we just created exists in all the teams(+scheduler)
+        # Check if the pds we just created exists in all the teams(+scheduler)
 
-        id_check_pds = backend_mpi.parallelize([pds.pds_id]*5)
+        id_check_pds = backend_mpi.parallelize([pds.pds_id] * 5)
         pds_check_result = backend_mpi.map(check_if_exists, id_check_pds)
-        self.assertTrue(False not in backend_mpi.collect(pds_check_result),"PDS was not created")
+        self.assertTrue(False not in backend_mpi.collect(pds_check_result), "PDS was not created")
 
-        #Delete the PDS on scheduler and try again
+        # Delete the PDS on scheduler and try again
         del pds
-        pds_check_result = backend_mpi.map(check_if_exists,id_check_pds)
-
-        self.assertTrue(True not in backend_mpi.collect(pds_check_result),"PDS was not deleted")
+        pds_check_result = backend_mpi.map(check_if_exists, id_check_pds)
 
+        self.assertTrue(True not in backend_mpi.collect(pds_check_result), "PDS was not deleted")
 
     def test_bds_delete(self):
-        
+
         def check_if_exists(x):
             obj = BackendMPITestHelper()
             return obj.check_bds(x)
 
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         bds = backend_mpi.broadcast(data)
 
-        #Check if the pds we just created exists in all the teams(+scheduler)
-        id_check_bds = backend_mpi.parallelize([bds.bds_id]*5)
+        # Check if the pds we just created exists in all the teams(+scheduler)
+        id_check_bds = backend_mpi.parallelize([bds.bds_id] * 5)
         bds_check_result = backend_mpi.map(check_if_exists, id_check_bds)
-        self.assertTrue(False not in backend_mpi.collect(bds_check_result),"BDS was not created")
+        self.assertTrue(False not in backend_mpi.collect(bds_check_result), "BDS was not created")
 
-        #Delete the PDS on scheduler and try again
+        # Delete the PDS on scheduler and try again
         del bds
-        bds_check_result = backend_mpi.map(check_if_exists,id_check_bds)
-        self.assertTrue(True not in backend_mpi.collect(bds_check_result),"BDS was not deleted")
-
+        bds_check_result = backend_mpi.map(check_if_exists, id_check_bds)
+        self.assertTrue(True not in backend_mpi.collect(bds_check_result), "BDS was not deleted")
 
     def test_function_pickle(self):
         def square(x):
-            return x**2
+            return x ** 2
 
         class staticfunctest:
-            @staticmethod 
+            @staticmethod
             def square(x):
-                return x**2
+                return x ** 2
 
         class nonstaticfunctest:
-            def square(self,x):
-                return x**2
+            def square(self, x):
+                return x ** 2
 
-        data = [1,2,3,4,5]
-        expected_result = [1,4,9,16,25]
+        data = [1, 2, 3, 4, 5]
+        expected_result = [1, 4, 9, 16, 25]
         pds = backend_mpi.parallelize(data)
 
-
-        pds_map1 = backend_mpi.map(square,pds)
+        pds_map1 = backend_mpi.map(square, pds)
         pds_res1 = backend_mpi.collect(pds_map1)
-        self.assertTrue(pds_res1==expected_result,"Failed pickle test for general function")
-
+        self.assertTrue(pds_res1 == expected_result, "Failed pickle test for general function")
 
-        pds_map2 = backend_mpi.map(lambda x:x**2,pds)
+        pds_map2 = backend_mpi.map(lambda x: x ** 2, pds)
         pds_res2 = backend_mpi.collect(pds_map2)
-        self.assertTrue(pds_res2==expected_result,"Failed pickle test for lambda function")
+        self.assertTrue(pds_res2 == expected_result, "Failed pickle test for lambda function")
 
-
-        pds_map3 = backend_mpi.map(staticfunctest.square,pds)
+        pds_map3 = backend_mpi.map(staticfunctest.square, pds)
         pds_res3 = backend_mpi.collect(pds_map3)
-        self.assertTrue(pds_res3==expected_result,"Failed pickle test for static function")
-
+        self.assertTrue(pds_res3 == expected_result, "Failed pickle test for static function")
 
         obj = nonstaticfunctest()
-        pds_map4 = backend_mpi.map(obj.square ,pds)
+        pds_map4 = backend_mpi.map(obj.square, pds)
         pds_res4 = backend_mpi.collect(pds_map4)
-        self.assertTrue(pds_res4==expected_result,"Failed pickle test for non-static function")
+        self.assertTrue(pds_res4 == expected_result, "Failed pickle test for non-static function")
 
     def test_exception_handling(self):
 
diff --git a/tests/backend_tests_mpi_model_mpi.py b/tests/backend_tests_mpi_model_mpi.py
index e6b7b1aa..3e69bceb 100644
--- a/tests/backend_tests_mpi_model_mpi.py
+++ b/tests/backend_tests_mpi_model_mpi.py
@@ -1,7 +1,10 @@
 import unittest
-from mpi4py import MPI
-from abcpy.backends import BackendMPI,BackendMPITestHelper
+
 import numpy
+from mpi4py import MPI
+
+from abcpy.backends import BackendMPI, BackendMPITestHelper
+
 
 def setUpModule():
     '''
@@ -16,52 +19,52 @@ def setUpModule():
     for the team and we now only need to write unit-tests from the scheduler's 
     point of view. 
     '''
-    global rank,backend_mpi
+    global rank, backend_mpi
     comm = MPI.COMM_WORLD
     rank = comm.Get_rank()
     backend_mpi = BackendMPI(process_per_model=2)
 
+
 class MPIBackendTests(unittest.TestCase):
 
     def test_parallelize(self):
-        data = [0]*backend_mpi.size()
+        data = [0] * backend_mpi.size()
         pds = backend_mpi.parallelize(data)
         pds_map = backend_mpi.map(lambda x, npc=None: x + MPI.COMM_WORLD.Get_rank(), pds)
         res = backend_mpi.collect(pds_map)
 
         for scheduler_index in backend_mpi.scheduler_node_ranks():
-            self.assertTrue(scheduler_index not in res,"Node in scheduler_node_ranks performed map.")
+            self.assertTrue(scheduler_index not in res, "Node in scheduler_node_ranks performed map.")
 
     def test_map(self):
         def square_mpi(x, npc=None):
-            local_res = numpy.array([2*(x**2)], 'i')
-            #global_res = numpy.array([0], 'i')
-            #MPI.COMM_WORLD.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
+            local_res = numpy.array([2 * (x ** 2)], 'i')
+            # global_res = numpy.array([0], 'i')
+            # MPI.COMM_WORLD.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
             return local_res[0]
-        
-        data = [1,2,3,4,5]
+
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
         pds_map = backend_mpi.map(square_mpi, pds)
         res = backend_mpi.collect(pds_map)
-        assert res==list(map(lambda x:2*(x**2),data))
-
+        assert res == list(map(lambda x: 2 * (x ** 2), data))
 
     def test_broadcast(self):
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
 
         bds = backend_mpi.broadcast(100)
 
-        #Pollute the BDS values of the scheduler to confirm teams
+        # Pollute the BDS values of the scheduler to confirm teams
         # use their broadcasted value
-        for k,v in  backend_mpi.bds_store.items():
-             backend_mpi.bds_store[k] = 99999
+        for k, v in backend_mpi.bds_store.items():
+            backend_mpi.bds_store[k] = 99999
 
         def test_map(x, npc=None):
             return x + bds.value()
 
         pds_m = backend_mpi.map(test_map, pds)
-        self.assertTrue(backend_mpi.collect(pds_m)==[101,102,103,104,105])
+        self.assertTrue(backend_mpi.collect(pds_m) == [101, 102, 103, 104, 105])
 
     def test_pds_delete(self):
 
@@ -71,79 +74,77 @@ def check_if_exists(x, npc):
                 return obj.check_pds(x)
             return None
 
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         pds = backend_mpi.parallelize(data)
 
-        #Check if the pds we just created exists in all the teams(+scheduler)
+        # Check if the pds we just created exists in all the teams(+scheduler)
 
-        id_check_pds = backend_mpi.parallelize([pds.pds_id]*5)
+        id_check_pds = backend_mpi.parallelize([pds.pds_id] * 5)
         pds_check_result = backend_mpi.map(check_if_exists, id_check_pds)
-        self.assertTrue(False not in backend_mpi.collect(pds_check_result),"PDS was not created")
+        self.assertTrue(False not in backend_mpi.collect(pds_check_result), "PDS was not created")
 
-        #Delete the PDS on scheduler and try again
+        # Delete the PDS on scheduler and try again
         del pds
-        pds_check_result = backend_mpi.map(check_if_exists,id_check_pds)
-
-        self.assertTrue(True not in backend_mpi.collect(pds_check_result),"PDS was not deleted")
+        pds_check_result = backend_mpi.map(check_if_exists, id_check_pds)
 
+        self.assertTrue(True not in backend_mpi.collect(pds_check_result), "PDS was not deleted")
 
     def test_bds_delete(self):
-        
+
         def check_if_exists(x, npc=None):
             obj = BackendMPITestHelper()
             return obj.check_bds(x)
 
-        data = [1,2,3,4,5]
+        data = [1, 2, 3, 4, 5]
         bds = backend_mpi.broadcast(data)
 
-        #Check if the pds we just created exists in all the teams(+scheduler)
-        id_check_bds = backend_mpi.parallelize([bds.bds_id]*5)
+        # Check if the pds we just created exists in all the teams(+scheduler)
+        id_check_bds = backend_mpi.parallelize([bds.bds_id] * 5)
         bds_check_result = backend_mpi.map(check_if_exists, id_check_bds)
-        self.assertTrue(False not in backend_mpi.collect(bds_check_result),"BDS was not created")
+        self.assertTrue(False not in backend_mpi.collect(bds_check_result), "BDS was not created")
 
-        #Delete the PDS on scheduler and try again
+        # Delete the PDS on scheduler and try again
         del bds
-        bds_check_result = backend_mpi.map(check_if_exists,id_check_bds)
-        self.assertTrue(True not in backend_mpi.collect(bds_check_result),"BDS was not deleted")
-
+        bds_check_result = backend_mpi.map(check_if_exists, id_check_bds)
+        self.assertTrue(True not in backend_mpi.collect(bds_check_result), "BDS was not deleted")
 
     def test_function_pickle(self):
 
         def square_mpi(x, npc=None):
-            local_res = numpy.array([2*(x**2)], 'i')
-            #global_res = numpy.array([0], 'i')
-            #model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
+            local_res = numpy.array([2 * (x ** 2)], 'i')
+            # global_res = numpy.array([0], 'i')
+            # model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
             return local_res[0]
 
         class staticfunctest_mpi:
-            @staticmethod 
+            @staticmethod
             def square_mpi(x, npc=None):
-                local_res = numpy.array([2*(x**2)], 'i')
-                #global_res = numpy.array([0], 'i')
-                #model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
+                local_res = numpy.array([2 * (x ** 2)], 'i')
+                # global_res = numpy.array([0], 'i')
+                # model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
                 return local_res[0]
 
         class nonstaticfunctest_mpi:
             def square_mpi(self, x, npc=None):
-                local_res = numpy.array([2*(x**2)], 'i')
-                #global_res = numpy.array([0], 'i')
-                #model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
+                local_res = numpy.array([2 * (x ** 2)], 'i')
+                # global_res = numpy.array([0], 'i')
+                # model_comm.Reduce([local_res,MPI.INT], [global_res,MPI.INT], op=MPI.SUM, root=0)
                 return local_res[0]
 
-        data = [1,2,3,4,5]
-        expected_result = [2,8,18,32,50]
+        data = [1, 2, 3, 4, 5]
+        expected_result = [2, 8, 18, 32, 50]
 
         pds = backend_mpi.parallelize(data)
-        pds_map1 = backend_mpi.map(square_mpi,pds)
+        pds_map1 = backend_mpi.map(square_mpi, pds)
         pds_res1 = backend_mpi.collect(pds_map1)
-        
-        self.assertTrue(pds_res1==expected_result,"Failed pickle test for general function")
 
-        pds_map3 = backend_mpi.map(staticfunctest_mpi.square_mpi,pds)
+        self.assertTrue(pds_res1 == expected_result, "Failed pickle test for general function")
+
+        pds_map3 = backend_mpi.map(staticfunctest_mpi.square_mpi, pds)
         pds_res3 = backend_mpi.collect(pds_map3)
-        self.assertTrue(pds_res3==expected_result,"Failed pickle test for static function")
+        self.assertTrue(pds_res3 == expected_result, "Failed pickle test for static function")
 
         obj = nonstaticfunctest_mpi()
-        pds_map4 = backend_mpi.map(obj.square_mpi ,pds)
+        pds_map4 = backend_mpi.map(obj.square_mpi, pds)
         pds_res4 = backend_mpi.collect(pds_map4)
-        self.assertTrue(pds_res4==expected_result,"Failed pickle test for non-static function")
+        self.assertTrue(pds_res4 == expected_result, "Failed pickle test for non-static function")
diff --git a/tests/continuousmodels_tests.py b/tests/continuousmodels_tests.py
index 8f4ed0ee..ac35f9a7 100644
--- a/tests/continuousmodels_tests.py
+++ b/tests/continuousmodels_tests.py
@@ -1,8 +1,8 @@
+import unittest
+
 from abcpy.continuousmodels import *
 from tests.probabilisticmodels_tests import AbstractAPIImplementationTests
 
-import unittest
-
 """Tests whether the methods defined for continuous probabilistic models are working as intended."""
 
 
@@ -10,18 +10,22 @@ class UniformAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [Uniform]
     model_inputs = [[[0, 1], [1, 2]]]
 
+
 class NormalAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [Normal]
-    model_inputs = [[0,1]]
+    model_inputs = [[0, 1]]
+
 
 class StundentTAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [StudentT]
     model_inputs = [[0, 3]]
 
+
 class MultivariateNormalAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [MultivariateNormal]
     model_inputs = [[[1, 0], [[1, 0], [0, 1]]]]
 
+
 class MultiStudentTAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [MultiStudentT]
     model_inputs = [[[1, 0], [[1, 0], [0, 1]], 3]]
@@ -69,39 +73,38 @@ def test_MultiStudentT(self):
             MultiStudentT([[1, 0], [[1, 0], [0, 1]], -1])
 
 
-
 class DimensionTests(unittest.TestCase):
     """Tests whether the dimensions of all continuous models are defined in the correct way."""
 
     def test_Uniform(self):
         U = Uniform([[0, 1], [1, 2]])
-        self.assertTrue(U.get_output_dimension()==2)
+        self.assertTrue(U.get_output_dimension() == 2)
 
     def test_Normal(self):
         N = Normal([1, 0.1])
-        self.assertTrue(N.get_output_dimension()==1)
+        self.assertTrue(N.get_output_dimension() == 1)
 
     def test_StudentT(self):
         S = StudentT([3, 1])
-        self.assertTrue(S.get_output_dimension()==1)
+        self.assertTrue(S.get_output_dimension() == 1)
 
     def test_MultivariateNormal(self):
         M = MultivariateNormal([[1, 0], [[1, 0], [0, 1]]])
-        self.assertTrue(M.get_output_dimension()==2)
+        self.assertTrue(M.get_output_dimension() == 2)
 
     def test_MultiStudentT(self):
         M = MultiStudentT([[1, 0], [[0.1, 0], [0, 0.1]], 1])
-        self.assertTrue(M.get_output_dimension()==2)
-
+        self.assertTrue(M.get_output_dimension() == 2)
 
 
 class SampleFromDistributionTests(unittest.TestCase):
     """Tests the return value of forward_simulate for all continuous distributions."""
+
     def test_Normal(self):
         N = Normal([1, 0.1])
         samples = N.forward_simulate(N.get_input_values(), 3)
         self.assertTrue(isinstance(samples, list))
-        self.assertTrue(len(samples)==3)
+        self.assertTrue(len(samples) == 3)
 
     def test_MultivariateNormal(self):
         M = MultivariateNormal([[1, 0], [[0.1, 0], [0, 0.1]]])
diff --git a/tests/discretemodels_tests.py b/tests/discretemodels_tests.py
index 78082df0..a6d09d50 100644
--- a/tests/discretemodels_tests.py
+++ b/tests/discretemodels_tests.py
@@ -1,8 +1,8 @@
+import unittest
+
 from abcpy.discretemodels import *
 from tests.probabilisticmodels_tests import AbstractAPIImplementationTests
 
-import unittest
-
 """Tests whether the methods defined for discrete probabilistic models are working as intended."""
 
 
@@ -10,18 +10,22 @@ class BernoulliAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [Bernoulli]
     model_inputs = [[0.5]]
 
+
 class BinomialAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [Binomial]
     model_inputs = [[3, 0.5]]
 
+
 class PoissonAPITests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [Poisson]
     model_inputs = [[3]]
 
+
 class DiscreteUniformTests(AbstractAPIImplementationTests, unittest.TestCase):
     model_types = [DiscreteUniform]
     model_inputs = [[10, 20]]
 
+
 class CheckParametersAtInitializationTests(unittest.TestCase):
     """Tests that no probabilistic model with invalid parameters can be initialized."""
 
@@ -62,28 +66,29 @@ class DimensionTests(unittest.TestCase):
 
     def test_Bernoulli(self):
         Bn = Bernoulli([0.5])
-        self.assertTrue(Bn.get_output_dimension()==1)
+        self.assertTrue(Bn.get_output_dimension() == 1)
 
     def test_Binomial(self):
         Bi = Binomial([1, 0.5])
-        self.assertTrue(Bi.get_output_dimension()==1)
+        self.assertTrue(Bi.get_output_dimension() == 1)
 
     def test_Poisson(self):
         Po = Poisson([3])
-        self.assertTrue(Po.get_output_dimension()==1)
+        self.assertTrue(Po.get_output_dimension() == 1)
 
     def test_DiscreteUniform(self):
         Du = DiscreteUniform([10, 20])
-        self.assertTrue(Du.get_output_dimension()==1)
+        self.assertTrue(Du.get_output_dimension() == 1)
 
 
 class SampleFromDistributionTests(unittest.TestCase):
     """Tests the return value of forward_simulate for all discrete distributions."""
+
     def test_Bernoulli(self):
         Bn = Bernoulli([0.5])
         samples = Bn.forward_simulate(Bn.get_input_values(), 3)
         self.assertTrue(isinstance(samples, list))
-        self.assertTrue(len(samples)==3)
+        self.assertTrue(len(samples) == 3)
 
     def test_Binomial(self):
         Bi = Binomial([1, 0.1])
diff --git a/tests/distances_tests.py b/tests/distances_tests.py
index 27ca83b2..c427f25e 100644
--- a/tests/distances_tests.py
+++ b/tests/distances_tests.py
@@ -1,61 +1,63 @@
 import unittest
+
 import numpy as np
 
 from abcpy.distances import Euclidean, PenLogReg, LogReg
 from abcpy.statistics import Identity
 
+
 class EuclideanTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc = Identity(degree = 1, cross = 0)
+        self.stat_calc = Identity(degree=1, cross=0)
         self.distancefunc = Euclidean(self.stat_calc)
-    
+
     def test_distance(self):
         # test simple distance computation
-        a = [[0, 0, 0],[0, 0, 0]]
-        b = [[0, 0, 0],[0, 0, 0]]
-        c = [[1, 1, 1],[1, 1, 1]]
-        #Checks whether wrong input type produces error message
+        a = [[0, 0, 0], [0, 0, 0]]
+        b = [[0, 0, 0], [0, 0, 0]]
+        c = [[1, 1, 1], [1, 1, 1]]
+        # Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.distancefunc.distance, 3.4, b)
         self.assertRaises(TypeError, self.distancefunc.distance, a, 3.4)
 
         # test input has different dimensionality
-        self.assertRaises(BaseException, self.distancefunc.distance, a, np.array([[0, 0], [1, 2]]))  
-        self.assertRaises(BaseException, self.distancefunc.distance, a, np.array([[0, 0, 0], [1, 2, 3], [4, 5, 6]]))        
+        self.assertRaises(BaseException, self.distancefunc.distance, a, np.array([[0, 0], [1, 2]]))
+        self.assertRaises(BaseException, self.distancefunc.distance, a, np.array([[0, 0, 0], [1, 2, 3], [4, 5, 6]]))
 
         # test whether they compute correct values
-        self.assertTrue(self.distancefunc.distance(a,b) == np.array([0]))
-        self.assertTrue(self.distancefunc.distance(a,c) == np.array([1.7320508075688772]))
-        
+        self.assertTrue(self.distancefunc.distance(a, b) == np.array([0]))
+        self.assertTrue(self.distancefunc.distance(a, c) == np.array([1.7320508075688772]))
+
     def test_dist_max(self):
-        self.assertTrue(self.distancefunc.dist_max() == np.inf)        
+        self.assertTrue(self.distancefunc.dist_max() == np.inf)
 
 
 class PenLogRegTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc = Identity(degree = 1, cross = 0)
+        self.stat_calc = Identity(degree=1, cross=0)
         self.distancefunc = PenLogReg(self.stat_calc)
-    
+
     def test_distance(self):
-        d1 = 0.5 * np.random.randn(100,2) - 10
-        d2 = 0.5 * np.random.randn(100,2) + 10
-        d3 = 0.5 * np.random.randn(95,2) + 10
-
-        d1=d1.tolist()
-        d2=d2.tolist()
-        d3=d3.tolist()
-        #Checks whether wrong input type produces error message
+        d1 = 0.5 * np.random.randn(100, 2) - 10
+        d2 = 0.5 * np.random.randn(100, 2) + 10
+        d3 = 0.5 * np.random.randn(95, 2) + 10
+
+        d1 = d1.tolist()
+        d2 = d2.tolist()
+        d3 = d3.tolist()
+        # Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
         self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
 
         # completely separable datasets should have a distance of 1.0
-        self.assertEqual(self.distancefunc.distance(d1,d2), 1.0)
+        self.assertEqual(self.distancefunc.distance(d1, d2), 1.0)
 
         # equal data sets should have a distance of 0.0
-        self.assertEqual(self.distancefunc.distance(d1,d1), 0.0)
-        
+        self.assertEqual(self.distancefunc.distance(d1, d1), 0.0)
+
         # equal data sets should have a distance of 0.0; check that in case where n_samples is not a multiple of n_folds
         # in cross validation (10)
-        self.assertEqual(self.distancefunc.distance(d3,d3), 0.0)
+        self.assertEqual(self.distancefunc.distance(d3, d3), 0.0)
 
     def test_dist_max(self):
         self.assertTrue(self.distancefunc.dist_max() == 1.0)
@@ -63,28 +65,29 @@ def test_dist_max(self):
 
 class LogRegTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc = Identity(degree = 1, cross = 0)
+        self.stat_calc = Identity(degree=1, cross=0)
         self.distancefunc = LogReg(self.stat_calc)
-        
+
     def test_distance(self):
-        d1 = 0.5 * np.random.randn(100,2) - 10
-        d2 = 0.5 * np.random.randn(100,2) + 10
+        d1 = 0.5 * np.random.randn(100, 2) - 10
+        d2 = 0.5 * np.random.randn(100, 2) + 10
+
+        d1 = d1.tolist()
+        d2 = d2.tolist()
 
-        d1=d1.tolist()
-        d2=d2.tolist()
-        
-        #Checks whether wrong input type produces error message
+        # Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
         self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
-        
+
         # completely separable datasets should have a distance of 1.0
-        self.assertEqual(self.distancefunc.distance(d1,d2), 1.0)
+        self.assertEqual(self.distancefunc.distance(d1, d2), 1.0)
 
         # equal data sets should have a distance of 0.0
-        self.assertEqual(self.distancefunc.distance(d1,d1), 0.0)
-        
+        self.assertEqual(self.distancefunc.distance(d1, d1), 0.0)
+
     def test_dist_max(self):
         self.assertTrue(self.distancefunc.dist_max() == 1.0)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/graphtools_tests.py b/tests/graphtools_tests.py
index 631f04e8..6929cf87 100644
--- a/tests/graphtools_tests.py
+++ b/tests/graphtools_tests.py
@@ -1,24 +1,26 @@
 import unittest
-from abcpy.inferences import *
+
+from abcpy.backends import BackendDummy as Backend
 from abcpy.continuousmodels import *
 from abcpy.discretemodels import *
 from abcpy.distances import LogReg
-from abcpy.statistics import Identity
-from abcpy.backends import BackendDummy as Backend
+from abcpy.inferences import *
 from abcpy.perturbationkernel import *
+from abcpy.statistics import Identity
 
 """Tests whether the methods defined for operations on the graph work as intended."""
 
 
 class SampleFromPriorTests(unittest.TestCase):
     """Tests whether sample_from_prior assigns new values to all nodes corresponding to free parameters in the graph."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.03, 0.01])
         N2 = Normal([0.1, N1])
         graph = Normal([B1, N2])
 
-        statistics_calculator = Identity(degree = 2, cross = False)
+        statistics_calculator = Identity(degree=2, cross=False)
         distance_calculator = LogReg(statistics_calculator)
         backend = Backend()
 
@@ -34,6 +36,7 @@ def test(self):
 
 class ResetFlagsTests(unittest.TestCase):
     """Tests whether it is possible to reset all visited flags in the graph."""
+
     def test(self):
         N1 = Normal([1, 0.1])
         N2 = Normal([N1, 0.1])
@@ -54,6 +57,7 @@ def test(self):
 
 class GetParametersTests(unittest.TestCase):
     """Tests whether get_stored_output_values returns only the free parameters of the graph."""
+
     def setUp(self):
         self.B1 = Binomial([10, 0.2])
         self.N1 = Normal([0.03, 0.01])
@@ -72,11 +76,12 @@ def setUp(self):
 
     def test(self):
         free_parameters = self.sampler.get_parameters()
-        self.assertEqual(len(free_parameters),3)
+        self.assertEqual(len(free_parameters), 3)
 
 
 class SetParametersTests(unittest.TestCase):
     """Tests whether it is possible to set values for all free parameters of the graph."""
+
     def setUp(self):
         self.B1 = Binomial([10, 0.2])
         self.N1 = Normal([0.03, 0.01])
@@ -104,6 +109,7 @@ def test(self):
 
 class GetCorrectOrderingTests(unittest.TestCase):
     """Tests whether get_correct_ordering will order the values of free parameters in recursive dfs order."""
+
     def setUp(self):
         self.B1 = Binomial([10, 0.2])
         self.N1 = Normal([0.03, 0.01])
@@ -123,11 +129,12 @@ def setUp(self):
     def test(self):
         parameters_and_models = [(self.N1, [0.029]), (self.B1, [3]), (self.N2, [0.12])]
         ordered_parameters = self.sampler.get_correct_ordering(parameters_and_models)
-        self.assertEqual(ordered_parameters, [3,0.12,0.029])
+        self.assertEqual(ordered_parameters, [3, 0.12, 0.029])
 
 
 class PerturbTests(unittest.TestCase):
     """Tests whether perturb will change all fixed values for free parameters."""
+
     def setUp(self):
         self.B1 = Binomial([10, 0.2])
         self.N1 = Normal([0.03, 0.01])
@@ -147,8 +154,10 @@ def setUp(self):
         kernel = DefaultKernel([self.N1, self.N2, self.B1])
         self.sampler.kernel = kernel
 
-        self.sampler.accepted_parameters_manager.update_broadcast(self.sampler.backend, [[3, 0.11, 0.029],[4,0.098, 0.031]], accepted_cov_mats = [[[1,0],[0,1]]], accepted_weights=np.array([1,1]))
-
+        self.sampler.accepted_parameters_manager.update_broadcast(self.sampler.backend,
+                                                                  [[3, 0.11, 0.029], [4, 0.098, 0.031]],
+                                                                  accepted_cov_mats=[[[1, 0], [0, 1]]],
+                                                                  accepted_weights=np.array([1, 1]))
 
         kernel_parameters = []
         for kernel in self.sampler.kernel.kernels:
@@ -156,7 +165,6 @@ def setUp(self):
                 self.sampler.accepted_parameters_manager.get_accepted_parameters_bds_values(kernel.models))
         self.sampler.accepted_parameters_manager.update_kernel_values(self.sampler.backend, kernel_parameters)
 
-
     def test(self):
         B1_value = self.B1.get_stored_output_values()
         N1_value = self.N1.get_stored_output_values()
@@ -171,6 +179,7 @@ def test(self):
 
 class SimulateTests(unittest.TestCase):
     """Tests whether the simulated data for multiple models has the correct format."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.03, 0.01])
@@ -192,13 +201,14 @@ def test(self):
 
         self.assertTrue(isinstance(y_sim, list))
 
-        self.assertTrue(len(y_sim)==2)
+        self.assertTrue(len(y_sim) == 2)
 
         self.assertTrue(isinstance(y_sim[0][0], np.ndarray))
 
 
 class GetMappingTests(unittest.TestCase):
     """Tests whether the private get_mapping method will return the correct mapping."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.03, 0.01])
@@ -217,16 +227,20 @@ def test(self):
         sampler.sample_from_prior(rng=rng)
 
         mapping, index = sampler._get_mapping()
-        self.assertTrue(mapping==[(B1, 0),(N2, 1),(N1,2)])
+        self.assertTrue(mapping == [(B1, 0), (N2, 1), (N1, 2)])
+
 
 from abcpy.continuousmodels import Uniform
 
+
 class PdfOfPriorTests(unittest.TestCase):
     """Tests the implemetation of pdf_of_prior"""
+
     def setUp(self):
         class Mockobject(Normal):
             def __init__(self, parameters):
                 super(Mockobject, self).__init__(parameters)
+
             def pdf(self, input_values, x):
                 return x
 
@@ -246,7 +260,7 @@ def pdf(self, input_values, x):
         self.sampler2 = RejectionABC([self.graph2], [distance_calculator], backend)
         self.sampler3 = RejectionABC(self.graph, [distance_calculator, distance_calculator], backend)
 
-        self.pdf1 = self.sampler1.pdf_of_prior(self.sampler1.model,  [1.32088846, 1.42945274])
+        self.pdf1 = self.sampler1.pdf_of_prior(self.sampler1.model, [1.32088846, 1.42945274])
         self.pdf2 = self.sampler2.pdf_of_prior(self.sampler2.model, [3])
         self.pdf3 = self.sampler3.pdf_of_prior(self.sampler3.model, [1.32088846, 1.42945274, 3])
 
@@ -265,6 +279,3 @@ def test_result(self):
 
 if __name__ == '__main__':
     unittest.main()
-
-
-
diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py
index a88392a9..3a17094d 100644
--- a/tests/inferences_tests.py
+++ b/tests/inferences_tests.py
@@ -1,18 +1,15 @@
 import unittest
+
 import numpy as np
 
+from abcpy.approx_lhd import SynLikelihood
 from abcpy.backends import BackendDummy
 from abcpy.continuousmodels import Normal
-
-from abcpy.distances import Euclidean
-
-from abcpy.approx_lhd import SynLikelihood
-
 from abcpy.continuousmodels import Uniform
-
+from abcpy.distances import Euclidean
+from abcpy.inferences import RejectionABC, PMC, PMCABC, SABC, ABCsubsim, SMCABC, APMCABC, RSMCABC
 from abcpy.statistics import Identity
 
-from abcpy.inferences import RejectionABC, PMC, PMCABC, SABC, ABCsubsim, SMCABC, APMCABC, RSMCABC
 
 class RejectionABCTest(unittest.TestCase):
     def test_sample(self):
@@ -23,11 +20,11 @@ def test_sample(self):
         mu = Uniform([[-5.0], [5.0]], name='mu')
         sigma = Uniform([[0.0], [10.0]], name='sigma')
         # define a Gaussian model
-        self.model = Normal([mu,sigma])
+        self.model = Normal([mu, sigma])
 
         # define sufficient statistics for the model
         stat_calc = Identity(degree=2, cross=0)
-        
+
         # define a distance function
         dist_calc = Euclidean(stat_calc)
 
@@ -35,54 +32,52 @@ def test_sample(self):
         y_obs = [np.array(9.8)]
 
         # use the rejection sampling scheme
-        sampler = RejectionABC([self.model], [dist_calc], dummy, seed = 1)
+        sampler = RejectionABC([self.model], [dist_calc], dummy, seed=1)
         journal = sampler.sample([y_obs], 10, 1, 10)
         mu_sample = np.array(journal.get_parameters()['mu'])
         sigma_sample = np.array(journal.get_parameters()['sigma'])
 
         # test shape of samples
         mu_shape, sigma_shape = (len(mu_sample), mu_sample[0].shape[1]), \
-                                                                    (len(sigma_sample),
-                                                                     sigma_sample[0].shape[1])
-        self.assertEqual(mu_shape, (10,1))
-        self.assertEqual(sigma_shape, (10,1))
+                                (len(sigma_sample),
+                                 sigma_sample[0].shape[1])
+        self.assertEqual(mu_shape, (10, 1))
+        self.assertEqual(sigma_shape, (10, 1))
 
         # Compute posterior mean
-        #self.assertAlmostEqual(np.average(np.asarray(samples[:,0])),1.22301,10e-2)
+        # self.assertAlmostEqual(np.average(np.asarray(samples[:,0])),1.22301,10e-2)
         self.assertLess(np.average(mu_sample) - 1.22301, 1e-2)
-        self.assertLess(np.average(sigma_sample) - 6.992218,10e-2)
-
-        self.assertFalse(journal.number_of_simulations==0)
-
+        self.assertLess(np.average(sigma_sample) - 6.992218, 10e-2)
 
+        self.assertFalse(journal.number_of_simulations == 0)
 
 
 class PMCTests(unittest.TestCase):
-        
+
     def test_sample(self):
         # setup backend
         backend = BackendDummy()
-        
+
         # define a uniform prior distribution
         mu = Uniform([[-5.0], [5.0]], name='mu')
         sigma = Uniform([[0.0], [10.0]], name='sigma')
         # define a Gaussian model
-        self.model = Normal([mu,sigma])
+        self.model = Normal([mu, sigma])
 
         # define sufficient statistics for the model
-        stat_calc = Identity(degree = 2, cross = 0)
+        stat_calc = Identity(degree=2, cross=0)
 
         # create fake observed data
-        #y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         y_obs = [np.array(9.8)]
-      
+
         # Define the likelihood function
         likfun = SynLikelihood(stat_calc)
 
-
         T, n_sample, n_samples_per_param = 1, 10, 100
-        sampler = PMC([self.model], [likfun], backend, seed = 1)
-        journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors =  np.array([.1,.1]), iniPoints = None)
+        sampler = PMC([self.model], [likfun], backend, seed=1)
+        journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors=np.array([.1, .1]),
+                                 iniPoints=None)
         mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
             journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
@@ -93,19 +88,19 @@ def test_sample(self):
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
                                                                     (len(sigma_post_sample),
                                                                      sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(abs(mu_post_mean - (-3.373004641385251)), 1e-3)
         self.assertLess(abs(sigma_post_mean - 6.519325027532673), 1e-3)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
-
         # use the PMC scheme for T = 2
         T, n_sample, n_samples_per_param = 2, 10, 100
-        sampler = PMC([self.model], [likfun], backend, seed = 1)
-        journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors = np.array([.1,.1]), iniPoints = None)
+        sampler = PMC([self.model], [likfun], backend, seed=1)
+        journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors=np.array([.1, .1]),
+                                 iniPoints=None)
         mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
             journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
@@ -116,9 +111,9 @@ def test_sample(self):
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
                                                                     (len(sigma_post_sample),
                                                                      sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(abs(mu_post_mean - (-3.2517600952705257)), 1e-3)
         self.assertLess(abs(sigma_post_mean - 6.9214661382633365), 1e-3)
 
@@ -142,23 +137,22 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
 
-        
     def test_calculate_weight(self):
         n_samples = 2
         rc = PMCABC([self.model], [self.dist_calc], self.backend, seed=1)
-        theta = np.array([1.0,1.0])
-
+        theta = np.array([1.0, 1.0])
 
         weight = rc._calculate_weight(theta)
         self.assertEqual(weight, 0.5)
-        
-        accepted_parameters = [[1.0, 1.0 + np.sqrt(2)],[0,0]]
+
+        accepted_parameters = [[1.0, 1.0 + np.sqrt(2)], [0, 0]]
         accepted_weights = np.array([[.5], [.5]])
-        accepted_cov_mat = [np.array([[1.0,0],[0,1]])]
-        rc.accepted_parameters_manager.update_broadcast(rc.backend, accepted_parameters, accepted_weights, accepted_cov_mat)
+        accepted_cov_mat = [np.array([[1.0, 0], [0, 1]])]
+        rc.accepted_parameters_manager.update_broadcast(rc.backend, accepted_parameters, accepted_weights,
+                                                        accepted_cov_mat)
         kernel_parameters = []
         for kernel in rc.kernel.kernels:
             kernel_parameters.append(
@@ -168,48 +162,50 @@ def test_calculate_weight(self):
         weight = rc._calculate_weight(theta)
         expected_weight = 0.170794684453
         self.assertAlmostEqual(weight, expected_weight)
-        
 
-        
     def test_sample(self):
         # use the PMCABC scheme for T = 1
         T, n_sample, n_simulate, eps_arr, eps_percentile = 1, 10, 1, [10], 10
-        sampler = PMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = PMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], T, eps_arr, n_sample, n_simulate, eps_percentile)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
-          
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
+
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - 0.03713, 10e-2)
         self.assertLess(sigma_post_mean - 7.727, 10e-2)
 
-        #self.assertEqual((mu_post_mean, sigma_post_mean), (,))
-        
+        # self.assertEqual((mu_post_mean, sigma_post_mean), (,))
+
         # use the PMCABC scheme for T = 2
-        T, n_sample, n_simulate, eps_arr, eps_percentile = 2, 10, 1, [10,5], 10
-        sampler = PMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        T, n_sample, n_simulate, eps_arr, eps_percentile = 2, 10, 1, [10, 5], 10
+        sampler = PMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         sampler.sample_from_prior(rng=np.random.RandomState(1))
         journal = sampler.sample([self.observation], T, eps_arr, n_sample, n_simulate, eps_percentile)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - 0.9356, 10e-2)
         self.assertLess(sigma_post_mean - 7.819, 10e-2)
 
@@ -232,49 +228,53 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
-       
+
     def test_sample(self):
         # use the SABC scheme for T = 1
         steps, epsilon, n_samples, n_samples_per_param = 1, 10, 10, 1
-        sampler = SABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = SABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, epsilon, n_samples, n_samples_per_param)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[0]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
 
         # use the SABC scheme for T = 2
         steps, epsilon, n_samples, n_samples_per_param = 2, 10, 10, 1
-        sampler = SABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = SABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, epsilon, n_samples, n_samples_per_param)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - 0.55859197, 10e-2)
         self.assertLess(sigma_post_mean - 7.03987723, 10e-2)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
+
 class ABCsubsimTests(unittest.TestCase):
     def setUp(self):
         # find spark and initialize it
@@ -291,46 +291,48 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
-       
-    def test_sample(self):
 
+    def test_sample(self):
         # use the ABCsubsim scheme for T = 1
         steps, n_samples, n_samples_per_param = 1, 10, 1
-        sampler = ABCsubsim([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = ABCsubsim([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, n_samples, n_samples_per_param)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
 
         # use the ABCsubsim scheme for T = 2
         steps, n_samples, n_samples_per_param = 2, 10, 1
-        sampler = ABCsubsim([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = ABCsubsim([self.model], [self.dist_calc], self.backend, seed=1)
         sampler.sample_from_prior(rng=np.random.RandomState(1))
         journal = sampler.sample([self.observation], steps, n_samples, n_samples_per_param)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
 
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - (-0.81410299), 10e-2)
         self.assertLess(sigma_post_mean - 9.25442675, 10e-2)
 
@@ -353,50 +355,54 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
 
-      
     def test_sample(self):
         # use the SMCABC scheme for T = 1
         steps, n_sample, n_simulate = 1, 10, 1
-        sampler = SMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = SMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, n_sample, n_simulate)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
 
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+        # self.assertEqual((mu_post_mean, sigma_post_mean), (,))
 
-        #self.assertEqual((mu_post_mean, sigma_post_mean), (,))
-        
         # use the SMCABC scheme for T = 2
         T, n_sample, n_simulate = 2, 10, 1
-        sampler = SMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = SMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], T, n_sample, n_simulate)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - (-0.786118677019), 10e-2)
         self.assertLess(sigma_post_mean - 4.63324738665, 10e-2)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
+
 class APMCABCTests(unittest.TestCase):
     def setUp(self):
         # find spark and initialize it
@@ -413,50 +419,53 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
 
-      
     def test_sample(self):
         # use the APMCABC scheme for T = 1
         steps, n_sample, n_simulate = 1, 10, 1
-        sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, n_sample, n_simulate, alpha=.9)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
 
         self.assertFalse(journal.number_of_simulations == 0)
 
-        
         # use the APMCABC scheme for T = 2
         T, n_sample, n_simulate = 2, 10, 1
-        sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = APMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], T, n_sample, n_simulate, alpha=.9)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
         self.assertLess(mu_post_mean - (-3.397848324005792), 10e-2)
         self.assertLess(sigma_post_mean - 6.451434816944525, 10e-2)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
+
 class RSMCABCTests(unittest.TestCase):
     def setUp(self):
         # find spark and initialize it
@@ -473,51 +482,55 @@ def setUp(self):
         self.dist_calc = Euclidean(stat_calc)
 
         # create fake observed data
-        #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
+        # self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist()
         self.observation = [np.array(9.8)]
 
-      
     def test_sample(self):
         # use the RSMCABC scheme for T = 1
         steps, n_sample, n_simulate = 1, 10, 1
-        sampler = RSMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = RSMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, n_sample, n_simulate)
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
 
         self.assertFalse(journal.number_of_simulations == 0)
 
-        #self.assertEqual((mu_post_mean, sigma_post_mean), (,))
-        
+        # self.assertEqual((mu_post_mean, sigma_post_mean), (,))
+
         # use the RSMCABC scheme for T = 2
         steps, n_sample, n_simulate = 2, 10, 1
-        sampler = RSMCABC([self.model], [self.dist_calc], self.backend, seed = 1)
+        sampler = RSMCABC([self.model], [self.dist_calc], self.backend, seed=1)
         journal = sampler.sample([self.observation], steps, n_sample, n_simulate)
         sampler.sample_from_prior(rng=np.random.RandomState(1))
-        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights())
+        mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(
+            journal.get_parameters()['sigma']), np.array(journal.get_weights())
 
         # Compute posterior mean
         mu_post_mean, sigma_post_mean = journal.posterior_mean()['mu'], journal.posterior_mean()['sigma']
 
         # test shape of sample
         mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \
-                                            (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape
-        self.assertEqual(mu_sample_shape, (10,1))
-        self.assertEqual(sigma_sample_shape, (10,1))
-        self.assertEqual(weights_sample_shape, (10,1))
-        self.assertLess(mu_post_mean - (1.52651600439), 10e-2)
+                                                                    (len(sigma_post_sample),
+                                                                     sigma_post_sample[0].shape[1]), post_weights.shape
+        self.assertEqual(mu_sample_shape, (10, 1))
+        self.assertEqual(sigma_sample_shape, (10, 1))
+        self.assertEqual(weights_sample_shape, (10, 1))
+        self.assertLess(mu_post_mean - 1.52651600439, 10e-2)
         self.assertLess(sigma_post_mean - 6.49994754262, 10e-2)
 
         self.assertFalse(journal.number_of_simulations == 0)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/jointapprox_lhd_tests.py b/tests/jointapprox_lhd_tests.py
index 1b086fb8..cb2369e9 100644
--- a/tests/jointapprox_lhd_tests.py
+++ b/tests/jointapprox_lhd_tests.py
@@ -1,15 +1,17 @@
 import unittest
+
 import numpy as np
 
 from abcpy.approx_lhd import SynLikelihood
-from abcpy.statistics import Identity
 from abcpy.continuousmodels import Normal, Uniform
 from abcpy.jointapprox_lhd import ProductCombination
+from abcpy.statistics import Identity
+
 
 class ProductCombinationTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc1 = Identity(degree = 1, cross = 0)
-        self.stat_calc2 = Identity(degree= 1, cross = 0)
+        self.stat_calc1 = Identity(degree=1, cross=0)
+        self.stat_calc2 = Identity(degree=1, cross=0)
         self.likfun1 = SynLikelihood(self.stat_calc1)
         self.likfun2 = SynLikelihood(self.stat_calc2)
         ## Define Models
@@ -17,27 +19,27 @@ def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')
         self.sigma = Uniform([[0.0], [10.0]], name='sigma')
         # define a Gaussian model
-        self.model1 = Normal([self.mu,self.sigma])
-        self.model2 = Normal([self.mu,self.sigma])
+        self.model1 = Normal([self.mu, self.sigma])
+        self.model2 = Normal([self.mu, self.sigma])
 
-        #Check whether wrong sized distnacefuncs gives an error
-        self.assertRaises(ValueError, ProductCombination, [self.model1,self.model2], [self.likfun1])
+        # Check whether wrong sized distnacefuncs gives an error
+        self.assertRaises(ValueError, ProductCombination, [self.model1, self.model2], [self.likfun1])
 
         self.jointapprox_lhd = ProductCombination([self.model1, self.model2], [self.likfun1, self.likfun2])
 
     def test_likelihood(self):
         # test simple distance computation
-        a = [[0, 0, 0],[0, 0, 0]]
-        b = [[0, 0, 0],[0, 0, 0]]
-        c = [[1, 1, 1],[1, 1, 1]]
+        a = [[0, 0, 0], [0, 0, 0]]
+        b = [[0, 0, 0], [0, 0, 0]]
+        c = [[1, 1, 1], [1, 1, 1]]
 
-        #Checks whether wrong input type produces error message
-        self.assertRaises(TypeError, self.jointapprox_lhd.likelihood, 3.4, [[2,1]])
-        self.assertRaises(TypeError, self.jointapprox_lhd.likelihood, [[2,4]], 3.4)
+        # Checks whether wrong input type produces error message
+        self.assertRaises(TypeError, self.jointapprox_lhd.likelihood, 3.4, [[2, 1]])
+        self.assertRaises(TypeError, self.jointapprox_lhd.likelihood, [[2, 4]], 3.4)
 
         # test input has different dimensionality
-        self.assertRaises(BaseException, self.jointapprox_lhd.likelihood, [a], [b,c])
-        self.assertRaises(BaseException, self.jointapprox_lhd.likelihood, [b,c], [a])
+        self.assertRaises(BaseException, self.jointapprox_lhd.likelihood, [a], [b, c])
+        self.assertRaises(BaseException, self.jointapprox_lhd.likelihood, [b, c], [a])
 
         # test whether they compute correct values
         # create observed data
diff --git a/tests/jointdistances_tests.py b/tests/jointdistances_tests.py
index 972d64ff..240fa1bc 100644
--- a/tests/jointdistances_tests.py
+++ b/tests/jointdistances_tests.py
@@ -1,15 +1,17 @@
 import unittest
+
 import numpy as np
 
-from abcpy.distances import Euclidean
-from abcpy.statistics import Identity
 from abcpy.continuousmodels import Normal, Uniform
+from abcpy.distances import Euclidean
 from abcpy.jointdistances import LinearCombination
+from abcpy.statistics import Identity
+
 
 class LinearCombinationTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc1 = Identity(degree = 1, cross = 0)
-        self.stat_calc2 = Identity(degree= 1, cross = 0)
+        self.stat_calc1 = Identity(degree=1, cross=0)
+        self.stat_calc2 = Identity(degree=1, cross=0)
         self.distancefunc1 = Euclidean(self.stat_calc1)
         self.distancefunc2 = Euclidean(self.stat_calc2)
         ## Define Models
@@ -17,35 +19,37 @@ def setUp(self):
         mu = Uniform([[-5.0], [5.0]], name='mu')
         sigma = Uniform([[0.0], [10.0]], name='sigma')
         # define a Gaussian model
-        self.model1 = Normal([mu,sigma])
-        self.model2 = Normal([mu,sigma])
+        self.model1 = Normal([mu, sigma])
+        self.model2 = Normal([mu, sigma])
 
-        #Check whether wrong sized distnacefuncs gives an error
-        self.assertRaises(ValueError, LinearCombination, [self.model1,self.model2], [self.distancefunc1], [1.0, 1.0])
+        # Check whether wrong sized distnacefuncs gives an error
+        self.assertRaises(ValueError, LinearCombination, [self.model1, self.model2], [self.distancefunc1], [1.0, 1.0])
 
-        #Check whether wrong sized weights gives an error
-        self.assertRaises(ValueError, LinearCombination, [self.model1,self.model2], [self.distancefunc1, self.distancefunc2], [1.0, 1.0, 1.0])
+        # Check whether wrong sized weights gives an error
+        self.assertRaises(ValueError, LinearCombination, [self.model1, self.model2],
+                          [self.distancefunc1, self.distancefunc2], [1.0, 1.0, 1.0])
 
-        self.jointdistancefunc = LinearCombination([self.model1,self.model2], [self.distancefunc1, self.distancefunc2], [1.0, 1.0])
+        self.jointdistancefunc = LinearCombination([self.model1, self.model2], [self.distancefunc1, self.distancefunc2],
+                                                   [1.0, 1.0])
 
     def test_distance(self):
         # test simple distance computation
-        a = [[0, 0, 0],[0, 0, 0]]
-        b = [[0, 0, 0],[0, 0, 0]]
-        c = [[1, 1, 1],[1, 1, 1]]
+        a = [[0, 0, 0], [0, 0, 0]]
+        b = [[0, 0, 0], [0, 0, 0]]
+        c = [[1, 1, 1], [1, 1, 1]]
 
-        #Checks whether wrong input type produces error message
+        # Checks whether wrong input type produces error message
         self.assertRaises(TypeError, self.jointdistancefunc.distance, 3.4, [b])
         self.assertRaises(TypeError, self.jointdistancefunc.distance, [a], 3.4)
 
         # test input has different dimensionality
-        self.assertRaises(BaseException, self.jointdistancefunc.distance, [a], [b,c])
-        self.assertRaises(BaseException, self.jointdistancefunc.distance, [b,c], [a])
+        self.assertRaises(BaseException, self.jointdistancefunc.distance, [a], [b, c])
+        self.assertRaises(BaseException, self.jointdistancefunc.distance, [b, c], [a])
 
         # test whether they compute correct values
-        self.assertTrue(self.jointdistancefunc.distance([a,b],[a,b]) == np.array([0]))
-        self.assertTrue(self.jointdistancefunc.distance([a,c],[c,b]) == np.array([1.7320508075688772]))
-        
+        self.assertTrue(self.jointdistancefunc.distance([a, b], [a, b]) == np.array([0]))
+        self.assertTrue(self.jointdistancefunc.distance([a, c], [c, b]) == np.array([1.7320508075688772]))
+
     def test_dist_max(self):
         self.assertTrue(self.jointdistancefunc.dist_max() == np.inf)
 
diff --git a/tests/modelselections_tests.py b/tests/modelselections_tests.py
index 4f11afae..8bdb745d 100644
--- a/tests/modelselections_tests.py
+++ b/tests/modelselections_tests.py
@@ -1,23 +1,25 @@
 import unittest
-from abcpy.continuousmodels import Uniform
+
+from abcpy.backends import BackendDummy as Backend
 from abcpy.continuousmodels import Normal
 from abcpy.continuousmodels import StudentT
-from abcpy.statistics import Identity
-from abcpy.backends import BackendDummy as Backend
+from abcpy.continuousmodels import Uniform
 from abcpy.modelselections import RandomForest
-     
+from abcpy.statistics import Identity
+
+
 class RandomForestTests(unittest.TestCase):
     def setUp(self):
         # define observation for true parameters mean=170, std=15
         self.y_obs = [160.82499176]
-        self.model_array = [None]*2
-        #Model 1: Gaussian
+        self.model_array = [None] * 2
+        # Model 1: Gaussian
         # define prior
         self.mu1 = Uniform([[150], [200]], name='mu1')
         self.sigma1 = Uniform([[5.0], [25.0]], name='sigma1')
         # define the model
         self.model_array[0] = Normal([self.mu1, self.sigma1])
-        #Model 2: Student t
+        # Model 2: Student t
         # define prior
         self.mu2 = Uniform([[150], [200]], name='mu2')
         self.sigma2 = Uniform([[1], [30.0]], name='sigma2')
@@ -25,22 +27,22 @@ def setUp(self):
         self.model_array[1] = StudentT([self.mu2, self.sigma2])
 
         # define statistics
-        self.statistics_calc = Identity(degree = 2, cross = False)
+        self.statistics_calc = Identity(degree=2, cross=False)
         # define backend
         self.backend = Backend()
 
-
     def test_select_model(self):
-        modelselection = RandomForest(self.model_array, self.statistics_calc, self.backend, seed = 1)
-        model = modelselection.select_model(self.y_obs,n_samples = 100, n_samples_per_param = 1)
+        modelselection = RandomForest(self.model_array, self.statistics_calc, self.backend, seed=1)
+        model = modelselection.select_model(self.y_obs, n_samples=100, n_samples_per_param=1)
 
         self.assertTrue(self.model_array[0] == model)
-    
+
     def test_posterior_probability(self):
-        modelselection = RandomForest(self.model_array, self.statistics_calc, self.backend, seed = 1)
+        modelselection = RandomForest(self.model_array, self.statistics_calc, self.backend, seed=1)
         model_prob = modelselection.posterior_probability(self.y_obs)
 
         self.assertTrue(model_prob > 0.7)
- 
+
+
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/tests/output_tests.py b/tests/output_tests.py
index c9aeacc1..c9a10fe1 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -1,8 +1,10 @@
 import unittest
+
 import numpy as np
 
 from abcpy.output import Journal
 
+
 class JournalTests(unittest.TestCase):
     # def test_add_parameters(self):
     #     params1 = np.zeros((2,4))
@@ -23,11 +25,9 @@ class JournalTests(unittest.TestCase):
     #     np.testing.assert_equal(journal_recon.parameters[0], params1)
     #     np.testing.assert_equal(journal_recon.parameters[1], params2)
 
-
-
     def test_add_weights(self):
-        weights1 = np.zeros((2,4))
-        weights2 = np.ones((2,4))
+        weights1 = np.zeros((2, 4))
+        weights2 = np.ones((2, 4))
 
         # test whether production mode only stores the last set of parameters
         journal_prod = Journal(0)
@@ -44,11 +44,9 @@ def test_add_weights(self):
         np.testing.assert_equal(journal_recon.weights[0], weights1)
         np.testing.assert_equal(journal_recon.weights[1], weights2)
 
-
-
     def test_add_opt_values(self):
-        opt_values1 = np.zeros((2,4))
-        opt_values2 = np.ones((2,4))
+        opt_values1 = np.zeros((2, 4))
+        opt_values2 = np.ones((2, 4))
 
         # test whether production mode only stores the last set of parameters
         journal_prod = Journal(0)
@@ -65,23 +63,18 @@ def test_add_opt_values(self):
         np.testing.assert_equal(journal_recon.opt_values[0], opt_values1)
         np.testing.assert_equal(journal_recon.opt_values[1], opt_values2)
 
-
-
     def test_load_and_save(self):
-        params1 = np.zeros((2,4))
-        weights1 = np.zeros((2,4))
+        params1 = np.zeros((2, 4))
+        weights1 = np.zeros((2, 4))
 
         journal = Journal(0)
-        #journal.add_parameters(params1)
+        # journal.add_parameters(params1)
         journal.add_weights(weights1)
         journal.save('journal_tests_testfile.pkl')
 
         new_journal = Journal.fromFile('journal_tests_testfile.pkl')
-        #np.testing.assert_equal(journal.parameters, new_journal.parameters)
+        # np.testing.assert_equal(journal.parameters, new_journal.parameters)
         np.testing.assert_equal(journal.weights, new_journal.weights)
-        
-
-
 
 
 if __name__ == '__main__':
diff --git a/tests/perturbationkernel_tests.py b/tests/perturbationkernel_tests.py
index b55498b7..d4b961a0 100644
--- a/tests/perturbationkernel_tests.py
+++ b/tests/perturbationkernel_tests.py
@@ -1,18 +1,21 @@
 import unittest
-from abcpy.continuousmodels import Normal
-from abcpy.discretemodels import Binomial
+
 from abcpy.acceptedparametersmanager import AcceptedParametersManager
 from abcpy.backends import BackendDummy as Backend
+from abcpy.continuousmodels import Normal
+from abcpy.discretemodels import Binomial
 from abcpy.perturbationkernel import *
 
 """Tests whether the methods for each perturbation kernel are working as intended"""
 
+
 class JointCheckKernelsTests(unittest.TestCase):
     """Tests whether value errors are raised correctly during initialization."""
+
     def test_Raises(self):
         N1 = Normal([0.1, 0.01])
         N2 = Normal([0.3, N1])
-        kernel = MultivariateNormalKernel([N1,N2,N1])
+        kernel = MultivariateNormalKernel([N1, N2, N1])
         with self.assertRaises(ValueError):
             JointPerturbationKernel([kernel])
 
@@ -28,6 +31,7 @@ def test_doesnt_raise(self):
 
 class CalculateCovTets(unittest.TestCase):
     """Tests whether the implementation of calculate_cov is working as intended."""
+
     def test(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
@@ -45,14 +49,16 @@ def test(self):
         Manager.update_kernel_values(backend, kernel_parameters)
 
         covs = kernel.calculate_cov(Manager)
-        self.assertTrue(len(covs)==2)
+        self.assertTrue(len(covs) == 2)
+
+        self.assertTrue(len(covs[0]) == 2)
 
-        self.assertTrue(len(covs[0])==2)
+        self.assertTrue(not (covs[1]))
 
-        self.assertTrue(not(covs[1]))
 
 class UpdateTests(unittest.TestCase):
     """Tests whether the values returned after perturbation are in the correct format for each perturbation kernel."""
+
     def test_DefaultKernel(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
@@ -62,7 +68,8 @@ def test_DefaultKernel(self):
         Manager = AcceptedParametersManager([graph])
         backend = Backend()
         kernel = DefaultKernel([N1, N2, B1])
-        Manager.update_broadcast(backend, [[2, 0.27, 0.097], [3, 0.32, 0.012]], np.array([1,1]), accepted_cov_mats=[[[0.01,0],[0,0.01]],[]])
+        Manager.update_broadcast(backend, [[2, 0.27, 0.097], [3, 0.32, 0.012]], np.array([1, 1]),
+                                 accepted_cov_mats=[[[0.01, 0], [0, 0.01]], []])
 
         kernel_parameters = []
         for krnl in kernel.kernels:
@@ -73,11 +80,13 @@ def test_DefaultKernel(self):
 
         rng = np.random.RandomState(1)
         perturbed_values_and_models = kernel.update(Manager, 1, rng)
-        self.assertEqual(perturbed_values_and_models, [(N1, [0.17443453636632419]), (N2, [0.25882435863499248]), (B1, [3])])
+        self.assertEqual(perturbed_values_and_models,
+                         [(N1, [0.17443453636632419]), (N2, [0.25882435863499248]), (B1, [3])])
 
 
 class PdfTests(unittest.TestCase):
     """Tests whether the pdf returns the correct results."""
+
     def test_return_value(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
@@ -93,11 +102,11 @@ def test_return_value(self):
             kernel_parameters.append(Manager.get_accepted_parameters_bds_values(krnl.models))
         Manager.update_kernel_values(backend, kernel_parameters)
         mapping, mapping_index = Manager.get_mapping(Manager.model)
-        covs = [[[1,0],[0,1]],[]]
+        covs = [[[1, 0], [0, 1]], []]
         Manager.update_broadcast(backend, accepted_cov_mats=covs)
-        pdf = kernel.pdf(mapping, Manager, Manager.accepted_parameters_bds.value()[1], [2,0.3,0.1])
+        pdf = kernel.pdf(mapping, Manager, Manager.accepted_parameters_bds.value()[1], [2, 0.3, 0.1])
         self.assertTrue(isinstance(pdf, float))
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/tests/pickle_tests.py b/tests/pickle_tests.py
index 976bd816..1e20a65b 100644
--- a/tests/pickle_tests.py
+++ b/tests/pickle_tests.py
@@ -1,7 +1,8 @@
+import pickle
 import unittest
+
 import cloudpickle
 import numpy as np
-import pickle
 
 '''We use pickle in our MPI backend to send a method from the master to the workers. The object with which this method is associated cotains the backend as an attribute, while the backend itself contains the data on which the workers should work. Pickling the method results in pickling the backend, which results in the whole data being pickled and sent, which is undersirable.
 
@@ -10,10 +11,11 @@
 This test checks whether everything is working correctly with cloudpickle.
 '''
 
+
 class ToBePickled:
     def __init__(self):
         self.included = 5
-        self.notIncluded = np.zeros(10**5)
+        self.notIncluded = np.zeros(10 ** 5)
 
     def __getstate__(self):
         """Method that tells cloudpickle which attributes should be pickled
@@ -26,12 +28,14 @@ def __getstate__(self):
         del state['notIncluded']
         return state
 
+
 class PickleTests(unittest.TestCase):
     def test_exclusion(self):
         """Tests whether after pickling and unpickling the object, the attribute which should not be included exists"""
         pickled_object = cloudpickle.dumps(ToBePickled(), pickle.HIGHEST_PROTOCOL)
         unpickled_object = cloudpickle.loads(pickled_object)
-        self.assertTrue(not(hasattr(pickled_object,'notIncluded')))
+        self.assertTrue(not (hasattr(pickled_object, 'notIncluded')))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/probabilisticmodels_tests.py b/tests/probabilisticmodels_tests.py
index 51ab998a..49d774ad 100644
--- a/tests/probabilisticmodels_tests.py
+++ b/tests/probabilisticmodels_tests.py
@@ -1,51 +1,54 @@
+import unittest
+
 from abcpy.continuousmodels import *
 from abcpy.probabilisticmodels import *
-import unittest
 
 """These test cases implement tests for the probabilistic model class."""
 
-class AbstractAPIImplementationTests():
+
+class AbstractAPIImplementationTests:
     def setUp(self):
         self.models = []
         for model_type, model_input in zip(self.model_types, self.model_inputs):
             model = model_type(model_input)
             self.models.append(model)
 
-
     def test__getitem__(self):
         for model in self.models:
             item = model[0]
-            self.assertTrue(isinstance(item, InputConnector), 'Return value not of type InputConnector for model {}.'.format(type(model)))
-
+            self.assertTrue(isinstance(item, InputConnector),
+                            'Return value not of type InputConnector for model {}.'.format(type(model)))
 
     def test_get_input_values(self):
         for model in self.models:
             values = model.get_input_values()
             self.assertTrue(isinstance(values, list), 'Return value not of type list in model {}.'.format(type(model)))
-            self.assertEqual(len(values), model.get_input_dimension(), 'Number of parameters not equal to input dimension of model {}.'.format(model))
-
+            self.assertEqual(len(values), model.get_input_dimension(),
+                             'Number of parameters not equal to input dimension of model {}.'.format(model))
 
     def test_get_input_models(self):
         for model in self.models:
             in_models = model.get_input_models()
-            self.assertTrue(isinstance(in_models, list), 'Return value not of type list in model {}.'.format(type(model)))
-            self.assertEqual(len(in_models), model.get_input_dimension(), 'Number of parameters not equal to input dimension of model {}.'.format(model))
-
+            self.assertTrue(isinstance(in_models, list),
+                            'Return value not of type list in model {}.'.format(type(model)))
+            self.assertEqual(len(in_models), model.get_input_dimension(),
+                             'Number of parameters not equal to input dimension of model {}.'.format(model))
 
     def test_get_stored_output_values(self):
         for model in self.models:
             rng = np.random.RandomState(1)
             model._forward_simulate_and_store_output(rng)
             out_values = model.get_stored_output_values()
-            self.assertTrue(isinstance(out_values, np.ndarray), 'Return value not of type numpy.array in model {}.'.format(type(model)))
-            self.assertEqual(len(out_values), model.get_output_dimension(), 'Number of parameters not equal to output dimension of model {}.'.format(model))
-
+            self.assertTrue(isinstance(out_values, np.ndarray),
+                            'Return value not of type numpy.array in model {}.'.format(type(model)))
+            self.assertEqual(len(out_values), model.get_output_dimension(),
+                             'Number of parameters not equal to output dimension of model {}.'.format(model))
 
     def test_get_input_connector(self):
         for model in self.models:
             in_con = model.get_input_connector()
-            self.assertTrue(isinstance(in_con, InputConnector) or in_con == None, 'Return value not of type InputConnector nor None in model {}.'.format(type(model)))
-
+            self.assertTrue(isinstance(in_con, InputConnector) or in_con == None,
+                            'Return value not of type InputConnector nor None in model {}.'.format(type(model)))
 
     def test_get_input_dimension(self):
         for model in self.models:
@@ -53,7 +56,6 @@ def test_get_input_dimension(self):
             self.assertTrue(isinstance(dim, Number), 'Return value not of type Number in model {}.'.format(type(model)))
             self.assertGreaterEqual(dim, 0, 'Input dimension must be larger than 0 for model {}.'.format(type(model)))
 
-
     def test_set_output_values(self):
         for model in self.models:
             number = 1
@@ -61,51 +63,61 @@ def test_set_output_values(self):
                 model.set_output_values(number)
             self.assertTrue(context.exception, 'Model {} should not accept a number as input.'.format(type(model)))
 
-            nparray = np.ones(model.get_output_dimension()+1)
+            nparray = np.ones(model.get_output_dimension() + 1)
             with self.assertRaises(IndexError) as context:
                 model.set_output_values(nparray)
-            self.assertTrue(context.exception, 'Model {} should only accept input equal to output dimension.'.format(type(model)))
+            self.assertTrue(context.exception,
+                            'Model {} should only accept input equal to output dimension.'.format(type(model)))
 
     def test_pdf(self):
         for model in self.models:
             x = 0
             input = model.get_input_values()
             pdf_at_x = model.pdf(input, x)
-            self.assertTrue(isinstance(pdf_at_x, Number), 'Return value not of type Number in model {}.'.format(type(model)))
-
+            self.assertTrue(isinstance(pdf_at_x, Number),
+                            'Return value not of type Number in model {}.'.format(type(model)))
 
     def test_check_input(self):
         for model in self.models:
             test_result = model._check_input(model.get_input_values())
-            self.assertTrue(test_result, 'The checking method should return True if input is reasonable in model {}.'.format(type(model)))
+            self.assertTrue(test_result,
+                            'The checking method should return True if input is reasonable in model {}.'.format(
+                                type(model)))
 
             with self.assertRaises(Exception) as context:
                 model._check_input(0)
-            self.assertTrue(context.exception, 'Function should raise an exception in model {} if input not of type InputConnector.'.format(type(model)))
-
+            self.assertTrue(context.exception,
+                            'Function should raise an exception in model {} if input not of type InputConnector.'.format(
+                                type(model)))
 
     def test_forward_simulate(self):
         for model in self.models:
             rng = np.random.RandomState(1)
             result_list = model.forward_simulate(model.get_input_values(), 3, rng)
-            self.assertTrue(isinstance(result_list, list), 'Return value not of type list in model {}.'.format(type(model)))
-            self.assertEqual(len(result_list), 3, 'Model {} did not return the requseted number of formard simulations.'.format(type(model)))
+            self.assertTrue(isinstance(result_list, list),
+                            'Return value not of type list in model {}.'.format(type(model)))
+            self.assertEqual(len(result_list), 3,
+                             'Model {} did not return the requseted number of formard simulations.'.format(type(model)))
 
             result = result_list[0]
-            self.assertTrue(isinstance(result, np.ndarray), 'A single forward simulation is not of type numpy.array in model {}.'.format(type(model)))
-
+            self.assertTrue(isinstance(result, np.ndarray),
+                            'A single forward simulation is not of type numpy.array in model {}.'.format(type(model)))
 
     def test_get_output_dimension(self):
         for model in self.models:
             expected_dim = model.get_output_dimension()
-            self.assertTrue(isinstance(expected_dim, Number), 'Return value not of type Number in model {}.'.format(type(model)))
-            self.assertGreater(expected_dim, 0, 'Output dimension must be larger than 0 for model {}.'.format(type(model)))
+            self.assertTrue(isinstance(expected_dim, Number),
+                            'Return value not of type Number in model {}.'.format(type(model)))
+            self.assertGreater(expected_dim, 0,
+                               'Output dimension must be larger than 0 for model {}.'.format(type(model)))
 
             rng = np.random.RandomState(1)
             result_list = model.forward_simulate(model.get_input_values(), 1, rng)
             result = result_list[0]
             result_dim = result.shape[0]
-            self.assertEqual(result_dim, expected_dim, 'Output dimension of forward simulation is not equal to get_output_dimension() for model {}.'.format(type(model)))
+            self.assertEqual(result_dim, expected_dim,
+                             'Output dimension of forward simulation is not equal to get_output_dimension() for model {}.'.format(
+                                 type(model)))
 
 
 class HyperParameterAPITests(AbstractAPIImplementationTests, unittest.TestCase):
@@ -126,13 +138,14 @@ def ReturnValueTest(self):
         """Tests whether the return value of the operator is correct"""
         N = Normal([1, 0.1], )
         result = N[0]
-        self.assertTrue(isinstance(result,tuple))
-        self.assertTrue(result[0]==N)
-        self.assertTrue(result[1]==0)
+        self.assertTrue(isinstance(result, tuple))
+        self.assertTrue(result[0] == N)
+        self.assertTrue(result[1] == 0)
 
 
 class MappingTest(unittest.TestCase):
     """Tests whether the mapping created during initialization is done correctly."""
+
     def setUp(self):
         self.U = Uniform([[0, 2], [1, 3]])
         self.M = MultivariateNormal([[self.U[1], self.U[0]], [[1, 0], [0, 1]]])
@@ -144,12 +157,12 @@ def test(self):
 
 class GetParameterValuesTest(unittest.TestCase):
     """Tests whether get_input_values returns the correct values."""
+
     def test(self):
         U = Uniform([[0, 2], [1, 3]])
         self.assertTrue(U.get_input_values() == [0, 2, 1, 3])
 
 
-
 class SampleParametersTest(unittest.TestCase):
     """Tests whether _forward_simulate_and_store_output returns False if the value of an input parameter is not an allowed value for the
     distribution."""
@@ -157,12 +170,13 @@ class SampleParametersTest(unittest.TestCase):
     def test(self):
         N1 = Normal([0.1, 0.01])
         N2 = Normal([1, N1])
-        N1._fixed_values=[-0.1]
+        N1._fixed_values = [-0.1]
         self.assertFalse(N2._check_input(N2.get_input_values()))
 
 
 class GetOutputValuesTest(unittest.TestCase):
     """Tests whether get_stored_output_values gives back values that can come from the distribution."""
+
     def test(self):
         U = Uniform([[0], [1]])
         U._forward_simulate_and_store_output()
@@ -175,7 +189,7 @@ def test_check_parameters_at_initialization(self):
         N1 = Normal([1, 0.1])
         M1 = MultivariateNormal([[1, 1], [[1, 0], [0, 1]]])
         with self.assertRaises(ValueError):
-            model = N1+M1
+            model = N1 + M1
 
         def test_initialization(self):
             M1 = MultivariateNormal([[1, 1], [[1, 0], [0, 1]]])
@@ -187,11 +201,10 @@ def test_initialization(self):
 class SummationModelTests(unittest.TestCase):
     """Tests whether all methods associated with the SummationModel are working as intended."""
 
-
     def test_forward_simulate(self):
         N1 = Normal([1, 0.1])
-        N2 = 10+N1
-        rng=np.random.RandomState(1)
+        N2 = 10 + N1
+        rng = np.random.RandomState(1)
         N1._forward_simulate_and_store_output(rng=rng)
 
         sample = N2.forward_simulate(N2.get_input_values(), 1, rng)
@@ -204,8 +217,8 @@ class SubtractionModelTests(unittest.TestCase):
 
     def test_forward_simulate(self):
         N1 = Normal([1, 0.1])
-        N2 = 10-N1
-        rng=np.random.RandomState(1)
+        N2 = 10 - N1
+        rng = np.random.RandomState(1)
         N1._forward_simulate_and_store_output(rng=rng)
 
         sample = N2.forward_simulate(N2.get_input_values(), 1, rng)
@@ -218,8 +231,8 @@ class MultiplicationModelTests(unittest.TestCase):
 
     def test_forward_simulate(self):
         N1 = Normal([1, 0.1])
-        N2 = N1*2
-        rng=np.random.RandomState(1)
+        N2 = N1 * 2
+        rng = np.random.RandomState(1)
         N1._forward_simulate_and_store_output(rng=rng)
 
         sample = N2.forward_simulate(N2.get_input_values(), 1, rng)
@@ -227,9 +240,9 @@ def test_forward_simulate(self):
 
     def test_multiplication_from_right(self):
         N1 = Normal([1, 0.1])
-        N2 = 2*N1
+        N2 = 2 * N1
 
-        self.assertTrue(N2.get_input_dimension()==2)
+        self.assertTrue(N2.get_input_dimension() == 2)
         self.assertTrue(isinstance(N2.get_input_connector().get_model(0), Hyperparameter))
 
 
@@ -239,7 +252,7 @@ class DivisionModelTests(unittest.TestCase):
     def test_sample_from_distribution(self):
         N1 = Normal([1, 0.1])
         N2 = Normal([2, 0.1])
-        N3 = N1/N2
+        N3 = N1 / N2
         rng = np.random.RandomState(1)
 
         N1._forward_simulate_and_store_output(rng=rng)
@@ -250,7 +263,7 @@ def test_sample_from_distribution(self):
 
     def test_division_from_right(self):
         N1 = Normal([1, 0.1])
-        N2 = 2/N1
+        N2 = 2 / N1
 
         self.assertEqual(N2.get_input_dimension(), 2)
         self.assertTrue(isinstance(N2.get_input_connector().get_model(0), Hyperparameter))
@@ -264,23 +277,23 @@ def test_check_parameters_at_initialization(self):
         M1 = MultivariateNormal([[1, 1], [[1, 0], [0, 1]]])
         N1 = Normal([1, 0.1])
         with self.assertRaises(ValueError):
-            N1**M1
+            N1 ** M1
 
     def test_initialization(self):
         """Tests that no errors during initialization are raised."""
         N1 = Normal([1, 0.1])
         N2 = Normal([1, 0.1])
 
-        N3 = N1**N2
+        N3 = N1 ** N2
 
-        N4 = N1**2
+        N4 = N1 ** 2
 
-        N5 = 2**N1
+        N5 = 2 ** N1
 
     def test_forward_simulate(self):
         """Tests whether forward_simulate gives the desired output."""
         N1 = Normal([1, 0.1])
-        N2 = N1**2
+        N2 = N1 ** 2
         rng = np.random.RandomState(1)
         N1._forward_simulate_and_store_output(rng=rng)
         sample = N2.forward_simulate(N2.get_input_values(), 1, rng=rng)
diff --git a/tests/statistics_tests.py b/tests/statistics_tests.py
index 6cf9bd75..8c08dea4 100644
--- a/tests/statistics_tests.py
+++ b/tests/statistics_tests.py
@@ -1,5 +1,7 @@
 import unittest
+
 import numpy as np
+
 from abcpy.statistics import Identity, LinearTransformation, NeuralEmbedding
 
 try:
diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py
index 39078a4c..c68b703f 100644
--- a/tests/statisticslearning_tests.py
+++ b/tests/statisticslearning_tests.py
@@ -1,9 +1,11 @@
 import unittest
+
 import numpy as np
-from abcpy.continuousmodels import Uniform
+
+from abcpy.backends import BackendDummy as Backend
 from abcpy.continuousmodels import Normal
+from abcpy.continuousmodels import Uniform
 from abcpy.statistics import Identity
-from abcpy.backends import BackendDummy as Backend
 from abcpy.statisticslearning import Semiautomatic, SemiautomaticNN, TripletDistanceLearning, \
     ContrastiveDistanceLearning
 
@@ -162,8 +164,9 @@ def setUp(self):
                                                               n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10)
             # with sample scaler:
             self.statisticslearning_with_scaler = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend,
-                                                              scale_samples=True,
-                                                              n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10)
+                                                                          scale_samples=True,
+                                                                          n_samples=100, n_samples_per_param=1, seed=1,
+                                                                          n_epochs=10)
 
     def test_initialization(self):
         if not has_torch:

From cba51b3651f799cd357cd2d46c2be63998af84ed Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 21:42:47 +0200
Subject: [PATCH 029/106] Other small change to inferences.py

---
 abcpy/inferences.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 2d2f00f2..5a51155d 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -962,15 +962,13 @@ def _calculate_weight(self, theta, npc=None):
         else:
             prior_prob = self.pdf_of_prior(self.model, theta)
 
-            denominator = 0.0
-
             mapping_for_kernels, garbage_index = self.accepted_parameters_manager.get_mapping(
                 self.accepted_parameters_manager.model)
 
-            for i in range(0, self.n_samples):
-                pdf_value = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
-                                            self.accepted_parameters_manager.accepted_parameters_bds.value()[i], theta)
-                denominator+=self.accepted_parameters_manager.accepted_weights_bds.value()[i,0]*pdf_value
+            pdf_values = np.array([self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
+                                                   self.accepted_parameters_manager.accepted_parameters_bds.value()[i],
+                                                   theta) for i in range(self.n_samples)])
+            denominator = np.sum(self.accepted_parameters_manager.accepted_weights_bds.value().reshape(-1) * pdf_values)
 
             return 1.0 * prior_prob / denominator
 

From 2224e66f9303581f99602faca4f1fcaab2e621b7 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 22 Oct 2020 21:56:27 +0200
Subject: [PATCH 030/106] Correct docstrings

---
 abcpy/approx_lhd.py |   8 ++-
 abcpy/distances.py  |   8 +--
 abcpy/inferences.py | 158 ++++++++++++++++++++++++++++++++++++--------
 3 files changed, 141 insertions(+), 33 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 9340d994..dc62df5b 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -113,8 +113,8 @@ class PenLogReg(Approx_likelihood, GraphTools):
     function. For lasso penalized logistic regression we use glmnet of Friedman et.
     al. [2].
     
-    [1] Reference: R. Dutta, J. Corander, S. Kaski, and M. U. Gutmann. Likelihood-free
-    inference by penalised logistic regression. arXiv:1611.10242, Nov. 2016.
+    [1] Thomas, O., Dutta, R., Corander, J., Kaski, S., & Gutmann, M. U. (2020).
+    Likelihood-free inference by ratio estimation. Bayesian Analysis.
     
     [2] Friedman, J., Hastie, T., and Tibshirani, R. (2010). Regularization 
     paths for generalized linear models via coordinate descent. Journal of Statistical 
@@ -127,7 +127,9 @@ class PenLogReg(Approx_likelihood, GraphTools):
     model : abcpy.models.Model
         Model object that conforms to the Model class.
     n_simulate : int
-        Number of data points in the simulated data set.
+        Number of data points to simulate for the reference data set; this has to be the same as n_samples_per_param
+        when calling the sampler. The reference data set is generated by drawing parameters from the prior and samples
+        from the model when PenLogReg is instantiated.
     n_folds: int, optional
         Number of folds for cross-validation. The default value is 10.
     max_iter: int, optional
diff --git a/abcpy/distances.py b/abcpy/distances.py
index 56e4d24c..c1532420 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -172,8 +172,8 @@ class PenLogReg(Distance):
     the most relevant summary statistics as explained in Gutmann et. al. [1].
     The maximum value of the distance is 1.0.
        
-    [1] Gutmann, M., Dutta, R., Kaski, S., and Corander, J. (2014). Statistical 
-    inference of intractable generative models via classification. arXiv:1407.4981.
+    [1] Gutmann, M. U., Dutta, R., Kaski, S., & Corander, J. (2018). Likelihood-free inference via classification.
+    Statistics and Computing, 28(2), 411-425.
     
     [2] Friedman, J., Hastie, T., and Tibshirani, R. (2010). Regularization 
     paths for generalized linear models via coordinate descent. Journal of Statistical 
@@ -240,8 +240,8 @@ class LogReg(Distance):
     accuracy [1]. The classification accuracy is calculated between two dataset d1 and d2 using 
     logistics regression and return it as a distance. The maximum value of the distance is 1.0.
 
-    [1] Gutmann, M., Dutta, R., Kaski, S., and Corander, J. (2014). Statistical 
-    inference of intractable generative models via classification. arXiv:1407.4981.
+    [1] Gutmann, M. U., Dutta, R., Kaski, S., & Corander, J. (2018). Likelihood-free inference via classification.
+    Statistics and Computing, 28(2), 411-425.
     """
 
     def __init__(self, statistics):
diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 5a51155d..ecf6b9c7 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -141,7 +141,7 @@ def distance(self):
 
 
 class RejectionABC(InferenceMethod):
-    """This base class implements the rejection algorithm based inference scheme [1] for
+    """This class implements the rejection algorithm based inference scheme [1] for
         Approximate Bayesian Computation.
 
         [1] Tavaré, S., Balding, D., Griffith, R., Donnelly, P.: Inferring coalescence
@@ -259,8 +259,10 @@ def _sample_parameter(self, rng, npc=None):
             The random number generator to be used.
         Returns
         -------
-        np.array
-            accepted parameter
+        Tuple
+            The first entry of the tuple is the accepted parameters.
+            The second entry is the distance between the simulated data set and the observation, while the third one is
+            the number of simulations needed to obtain the accepted parameter.
         """
         distance = self.distance.dist_max()
 
@@ -290,7 +292,7 @@ def _sample_parameter(self, rng, npc=None):
 
 class PMCABC(BaseDiscrepancy, InferenceMethod):
     """
-    This base class implements a modified version of Population Monte Carlo based inference scheme for Approximate
+    This class implements a modified version of Population Monte Carlo based inference scheme for Approximate
     Bayesian computation of Beaumont et. al. [1]. Here the threshold value at `t`-th generation are adaptively chosen by
     taking the maximum between the epsilon_percentile-th value of discrepancies of the accepted parameters at `t-1`-th
     generation and the threshold value provided for this generation by the user. If we take the value of
@@ -531,8 +533,10 @@ def _resample_parameter(self, rng, npc=None):
 
         Returns
         -------
-        np.array
-            accepted parameter
+        Tuple
+            The first entry of the tuple is the accepted parameters.
+            The second entry is the distance between the simulated data set and the observation, while the third one is
+            the number of simulations needed to obtain the accepted parameter.
         """
 
         # print(npc.communicator())
@@ -609,6 +613,21 @@ def _calculate_weight(self, theta, npc=None):
             return 1.0 * prior_prob / denominator
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with covFactor and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        covFactor : float
+            factor to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
         accepted_cov_mats = []
         for new_cov_mat in new_cov_mats:
@@ -973,6 +992,21 @@ def _calculate_weight(self, theta, npc=None):
             return 1.0 * prior_prob / denominator
 
     def _compute_accepted_cov_mats(self, covFactors, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with covFactors and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        covFactors : list of float
+            factors to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         accepted_cov_mats = []
         for covFactor, new_cov_mat in zip(covFactors, new_cov_mats):
             if not (new_cov_mat.size == 1):
@@ -984,7 +1018,8 @@ def _compute_accepted_cov_mats(self, covFactors, new_cov_mats):
 
 class SABC(BaseDiscrepancy, InferenceMethod):
     """
-    This base class implements a modified version of Simulated Annealing Approximate Bayesian Computation (SABC) of [1] when the prior is non-informative.
+    This class implements a modified version of Simulated Annealing Approximate Bayesian Computation (SABC) of [1]
+    when the prior is non-informative.
 
     [1] C. Albert, H. R. Kuensch and A. Scheidegger. A Simulated Annealing Approach to
     Approximate Bayes Computations. Statistics and Computing, (2014).
@@ -1060,16 +1095,18 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
             Number of samples to generate. The default value is 10000.
         n_samples_per_param : integer, optional
             Number of data points in each simulated data set. The default value is 1.
-        beta : numpy.float
-            Tuning parameter of SABC, default value is 2.
-        delta : numpy.float
+        beta : numpy.float, optional
+            Tuning parameter of SABC, default value is 2. Used to scale up the covariance matrices obtained from data.
+        delta : numpy.float, optional
             Tuning parameter of SABC, default value is 0.2.
         v : numpy.float, optional
             Tuning parameter of SABC, The default value is 0.3.
-        ar_cutoff : numpy.float
-            Acceptance ratio cutoff, The default value is 0.1.
+        ar_cutoff : numpy.float, optional
+            Acceptance ratio cutoff: if the acceptance rate at some iteration of the algorithm is lower than that, the
+            algorithm will stop. The default value is 0.1.
         resample: int, optional
-            Resample after this many acceptance, The default value is None which takes value inside n_samples
+            At any iteration, perform a resampling step if the number of accepted particles is larger than resample.
+            When not provided, it assumes resample to be equal to n_samples.
         n_update: int, optional
             Number of perturbed parameters at each step, The default value is None which takes value inside n_samples
         full_output: integer, optional
@@ -1471,6 +1508,21 @@ def _accept_parameter(self, data, npc=None):
         return new_theta, distance, all_parameters, all_distances, index, acceptance, counter
 
     def _compute_accepted_cov_mats(self, beta, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with beta and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        beta : float
+            factor to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         accepted_cov_mats = []
         for new_cov_mat in new_cov_mats:
             if not (new_cov_mat.size == 1):
@@ -1482,7 +1534,7 @@ def _compute_accepted_cov_mats(self, beta, new_cov_mats):
 
 
 class ABCsubsim(BaseDiscrepancy, InferenceMethod):
-    """This base class implements Approximate Bayesian Computation by subset simulation (ABCsubsim) algorithm of [1].
+    """This class implements Approximate Bayesian Computation by subset simulation (ABCsubsim) algorithm of [1].
 
     [1] M. Chiachio, J. L. Beck, J. Chiachio, and G. Rus., Approximate Bayesian computation by subset
     simulation. SIAM J. Sci. Comput., 36(3):A1339–A1358, 2014/10/03 2014.
@@ -1876,7 +1928,7 @@ def _update_cov_mat(self, rng_t, npc=None):
 
 
 class RSMCABC(BaseDiscrepancy, InferenceMethod):
-    """This base class implements Replenishment Sequential Monte Carlo Approximate Bayesian computation of
+    """This class implements Replenishment Sequential Monte Carlo Approximate Bayesian computation of
     Drovandi and Pettitt [1].
 
     [1] CC. Drovandi CC and AN. Pettitt, Estimation of parameters for macroparasite population evolution using
@@ -2207,6 +2259,21 @@ def _accept_parameter(self, rng, npc=None):
         return self.get_parameters(self.model), distance, index_accept, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with covFactor and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        covFactor : float
+            factor to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
         accepted_cov_mats = []
         for new_cov_mat in new_cov_mats:
@@ -2219,7 +2286,7 @@ def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
 
 
 class APMCABC(BaseDiscrepancy, InferenceMethod):
-    """This base class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
+    """This class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
     M. Lenormand et al. [1].
 
     [1] M. Lenormand, F. Jabot and G. Deffuant, Adaptive approximate Bayesian computation
@@ -2525,6 +2592,21 @@ def _accept_parameter(self, rng, npc=None):
         return self.get_parameters(self.model), distance, weight, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with covFactor and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        covFactor : float
+            factor to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
         accepted_cov_mats = []
         for new_cov_mat in new_cov_mats:
@@ -2536,12 +2618,15 @@ def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
         return accepted_cov_mats
 
 class SMCABC(BaseDiscrepancy, InferenceMethod):
-    """This base class implements Adaptive Population Monte Carlo Approximate Bayesian computation of
+    """This class implements Sequential Monte Carlo Approximate Bayesian computation of
     Del Moral et al. [1].
 
     [1] P. Del Moral, A. Doucet, A. Jasra, An adaptive sequential Monte Carlo method for approximate
     Bayesian computation. Statistics and Computing, 22(5):1009–1020, 2012.
 
+    [2] Lee, Anthony. "n the choice of MCMC kernels for approximate Bayesian computation with SMC samplers.
+    Proceedings of the 2012 Winter Simulation Conference (WSC). IEEE, 2012.
+
     Parameters
     ----------
     model : list
@@ -2613,18 +2698,23 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep
         n_samples_per_param : integer, optional
             Number of data points in each simulated data set. The default value is 1.
         epsilon_final : float, optional
-            The final threshold value of epsilon to be reached. The default value is 0.1.
+            The final threshold value of epsilon to be reached; if at some iteration you reach a lower epsilon than
+            epsilon_final, the algorithm will stop and not proceed with further iterations. The default value is 0.1.
         alpha : float, optional
             A parameter taking values between [0,1], determinining the rate of change of the threshold epsilon. The
             default value is 0.95.
         covFactor : float, optional
             scaling parameter of the covariance matrix. The default value is 2.
+        resample  : float, optional
+            It defines the resample step: introduce a resample step, after the particles have been
+            perturbed and the new weights have been computed, if the effective sample size is smaller than resample. If
+            not provided, resample is set to 0.5 * n_samples.
         full_output: integer, optional
             If full_output==1, intermediate results are included in output journal.
             The default value is 0, meaning the intermediate results are not saved.
         which_mcmc_kernel: integer, optional
-            Specifies which MCMC kernel to be used: '0' kernel suggestd in [1], any other value will use r-hit kernel
-            suggested by Anthony Lee. The default value is 0.
+            Specifies which MCMC kernel to be used: '0' kernel suggested in [1], any other value will use r-hit kernel
+            suggested by Anthony Lee [2]. The default value is 0.
         journal_file: str, optional
             Filename of a journal file to read an already saved journal file, from which the first iteration will start.
             The default value is None.
@@ -2726,7 +2816,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep
                 new_weights = np.ones(shape=n_samples, ) * (1.0 / n_samples)
 
             # 2: Resample
-            if accepted_y_sim != None and pow(sum(pow(new_weights, 2)), -1) < resample:
+            if accepted_y_sim is not None and pow(sum(pow(new_weights, 2)), -1) < resample:
                 self.logger.info("Resampling")
                 # Weighted resampling:
                 index_resampled = self.rng.choice(n_samples, n_samples, replace=True, p=new_weights)
@@ -2956,20 +3046,21 @@ def _accept_parameter(self, rng_and_index, npc=None):
 
     def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
         """
-        Samples a single model parameter and simulate from it until
-        distance between simulated outcome and the observation is
-        smaller than epsilon.
+        This implements algorithm 5 in Lee (2012) [2] which is used as an MCMC kernel in SMCABC. This implementation
+        uses r=3.
 
         Parameters
         ----------
-        seed_and_index: numpy.ndarray
-            2 dimensional array. The first entry specifies the initial seed for the random number generator.
+        rng_and_index: numpy.ndarray
+            2 dimensional array. The first entry is a random number generator.
             The second entry defines the index in the data set.
 
         Returns
         -------
         Tuple
             The first entry of the tuple is the accepted parameters. The second entry is the simulated data set.
+            The third one is the distance between the simulated data set and the observation, while the fourth one is
+            the number of simulations needed to obtain the accepted parameter.
         """
 
         rng = rng_and_index[0]
@@ -3044,6 +3135,21 @@ def _accept_parameter_r_hit_kernel(self, rng_and_index, npc=None):
         return self.get_parameters(), y_sim, distance, counter
 
     def _compute_accepted_cov_mats(self, covFactor, new_cov_mats):
+        """
+        Update the covariance matrices computed from data by multiplying them with covFactor and adding a small term in
+        the diagonal for numerical stability.
+
+        Parameters
+        ----------
+        covFactor : float
+            factor to correct the covariance matrices
+        new_cov_mats : list
+            list of covariance matrices computed from data
+        Returns
+        -------
+        list
+            List of new accepted covariance matrices
+        """
         # accepted_cov_mats = [covFactor * cov_mat for cov_mat in accepted_cov_mats]
         accepted_cov_mats = []
         for new_cov_mat in new_cov_mats:

From 7037774198a6da7b9995b05db02d929931d69597 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 11:08:53 +0200
Subject: [PATCH 031/106] Fix test

---
 tests/approx_lhd_tests.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index f9d9b8f6..2f4f28af 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -52,7 +52,7 @@ def setUp(self):
         self.mu = Uniform([[-5.0], [5.0]], name='mu')
         self.sigma = Uniform([[5.0], [10.0]], name='sigma')
         self.model = Normal([self.mu, self.sigma])
-        self.stat_calc = Identity(degree=2, cross=0)
+        self.stat_calc = Identity(degree=2, cross=False)
         self.likfun = SynLikelihood(self.stat_calc)
 
     def test_likelihood(self):
@@ -61,16 +61,17 @@ def test_likelihood(self):
         self.assertRaises(TypeError, self.likfun.likelihood, [2, 4], 3.4)
 
         # create observed data
-        y_obs = [9.8]
+        y_obs = [1.8]
         # create fake simulated data
         self.mu._fixed_values = [1.1]
         self.sigma._fixed_values = [1.0]
         y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
         # calculate the statistics of the observed data
         comp_likelihood = self.likfun.likelihood(y_obs, y_sim)
-        expected_likelihood = 0.00924953470649
+        expected_likelihood = 0.20963610211945238
         # This checks whether it computes a correct value and dimension is right
-        self.assertLess(comp_likelihood - expected_likelihood, 10e-2)
+        self.assertAlmostEqual(comp_likelihood, expected_likelihood)
+
 
 if __name__ == '__main__':
     unittest.main()

From c9be03b66ea63ffa37033dcc3a52bade2d8fcb2d Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 11:16:20 +0200
Subject: [PATCH 032/106] Add test in PenLogReg approx_lhd for checking if
 number of samples in the reference dataset is same as generated ones.

---
 abcpy/approx_lhd.py       | 4 ++++
 tests/approx_lhd_tests.py | 5 +++++
 2 files changed, 9 insertions(+)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index dc62df5b..6749c70f 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -178,6 +178,10 @@ def likelihood(self, y_obs, y_sim):
 
         # Extract summary statistics from the simulated data
         stat_sim = self.statistics_calc.statistics(y_sim)
+        if not stat_sim.shape[0] == self.n_simulate:
+            raise RuntimeError("The number of samples in the reference data set is not the same as the number of "
+                               "samples in the generated data. Please check that `n_samples` in the `sample()` method"
+                               "for the sampler is equal to `n_simulate` in PenLogReg.")
 
         # Compute the approximate likelihood for the y_obs given theta
         y = np.append(np.zeros(self.n_simulate), np.ones(self.n_simulate))
diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index 2f4f28af..d1b09651 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -16,6 +16,8 @@ def setUp(self):
         self.model_bivariate = Uniform([[0, 0], [1, 1]], name="model")
         self.stat_calc = Identity(degree=2, cross=1)
         self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate=100, n_folds=10, max_iter=100000, seed=1)
+        self.likfun_wrong_n_sim = PenLogReg(self.stat_calc, [self.model], n_simulate=10, n_folds=10, max_iter=100000,
+                                            seed=1)
         self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10,
                                           max_iter=100000, seed=1)
 
@@ -37,6 +39,9 @@ def test_likelihood(self):
         # self.assertLess(comp_likelihood - expected_likelihood, 10e-2)
         self.assertAlmostEqual(comp_likelihood, expected_likelihood)
 
+        # check if it returns the correct error when n_samples does not match:
+        self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.likelihood, y_obs, y_sim)
+
         # try now with the bivariate uniform model:
         y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1,
                                                                 rng=np.random.RandomState(1))

From 871bfde0cceb47d405e7e705f3cc8821372aa93b Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 11:16:42 +0200
Subject: [PATCH 033/106] Add more arguments to load_net

---
 abcpy/NN_utilities/utilities.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/abcpy/NN_utilities/utilities.py b/abcpy/NN_utilities/utilities.py
index 4f5cffc8..61a07d9b 100644
--- a/abcpy/NN_utilities/utilities.py
+++ b/abcpy/NN_utilities/utilities.py
@@ -49,8 +49,8 @@ def save_net(path, net):
     torch.save(net.state_dict(), path)
 
 
-def load_net(path, network_class):
+def load_net(path, network_class, *network_args, **network_kwargs):
     """Function to load a network from a Pytorch state_dict, given the corresponding network_class."""
-    net = network_class()
+    net = network_class(*network_args, **network_kwargs)
     net.load_state_dict(torch.load(path))
     return net.eval()  # call the network to eval model. Needed with batch normalization and dropout layers.

From 951ce049001ee34596c4c11572dbfdbc499cbcfa Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 11:38:39 +0200
Subject: [PATCH 034/106] Some updates in the examples

---
 .../approx_lhd/pmc_hierarchical_models.py     | 21 ++++++++++---------
 .../extensions/distances/default_distance.py  |  7 ++-----
 ...mcabc_inference_on_multiple_sets_of_obs.py | 20 +++++++++++-------
 .../randomforest_modelselections.py           |  8 ++++++-
 4 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/examples/approx_lhd/pmc_hierarchical_models.py b/examples/approx_lhd/pmc_hierarchical_models.py
index c6b34786..8798dbae 100644
--- a/examples/approx_lhd/pmc_hierarchical_models.py
+++ b/examples/approx_lhd/pmc_hierarchical_models.py
@@ -1,8 +1,9 @@
-"""An example showing how to implement a bayesian network in ABCpy"""
+"""An example showing how to implement a bayesian network in ABCpy. We consider here a model of school grades which
+depend on some variables."""
 
 
 def infer_parameters():
-    # The data corresponding to model_1 defined below
+    # Observed data corresponding to model_1 defined below
     grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
                   4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
                   3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705,
@@ -31,10 +32,10 @@ def infer_parameters():
     # The grade a student would receive without any bias
     grade_without_additional_effects = Normal([[4.5], [0.25]], )
 
-    # The grade a student of a certain school receives
+    # The grade a student of a certain school receives; this defined a new random variable by subtraction
     final_grade = grade_without_additional_effects - class_size - background
 
-    # The data corresponding to model_2 defined below
+    # Observed data corresponding to model_2 defined below
     scholarship_obs = [2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192,
                        3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992,
                        2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971,
@@ -61,7 +62,7 @@ def infer_parameters():
     statistics_calculator_final_grade = Identity(degree=2, cross=False)
     statistics_calculator_final_scholarship = Identity(degree=3, cross=False)
 
-    # Define a distance measure for final grade and final scholarship
+    # Define an approximate likelihood for final grade and final scholarship
     from abcpy.approx_lhd import SynLikelihood
     approx_lhd_final_grade = SynLikelihood(statistics_calculator_final_grade)
     approx_lhd_final_scholarship = SynLikelihood(statistics_calculator_final_scholarship)
@@ -70,22 +71,22 @@ def infer_parameters():
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
 
-    # Define a perturbation kernel
+    # Define a perturbation kernel to explore parameter space
     from abcpy.perturbationkernel import DefaultKernel
-    kernel = DefaultKernel([school_location, class_size, grade_without_additional_effects, \
+    kernel = DefaultKernel([school_location, class_size, grade_without_additional_effects,
                             background, scholarship_without_additional_effects])
 
     # Define sampling parameters
     T, n_sample, n_samples_per_param = 3, 250, 10
 
-    # Define sampler
+    # Define sampler to use with the
     from abcpy.inferences import PMC
-    sampler = PMC([final_grade, final_scholarship], \
+    sampler = PMC([final_grade, final_scholarship],
                   [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel)
 
     # Sample
     journal = sampler.sample([grades_obs, scholarship_obs], T, n_sample, n_samples_per_param)
-
+    return journal
 
 def analyse_journal(journal):
     # output parameters and weights
diff --git a/examples/extensions/distances/default_distance.py b/examples/extensions/distances/default_distance.py
index d80774c1..f3eadf17 100644
--- a/examples/extensions/distances/default_distance.py
+++ b/examples/extensions/distances/default_distance.py
@@ -5,16 +5,13 @@
 
 class DefaultJointDistance(Distance):
     """
-    This class implements a default distance to be used when multiple root
-    models exist. It uses LogReg as the distance calculator for each root model, and
-    adds all individual distances.
+    This class shocases how to implement a distance. It is actually a wrapper of the Euclidean distance, which is
+    applied on each component of the provided datasets and summed.
 
     Parameters
     ----------
     statistics: abcpy.statistics object
         The statistics calculator to be used
-    number_of_models: integer
-        The number of root models on which the distance will act.
     """
 
     def __init__(self, statistics):
diff --git a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
index 628b6071..ea60c36a 100644
--- a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
+++ b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
@@ -1,6 +1,8 @@
 import numpy as np
 
-"""An example showing how to implement a bayesian network in ABCpy"""
+"""An example showing how to implement a bayesian network in ABCpy. We consider here two hierarchical models which 
+depend on a common set of parameters (with prior distributions) and for which we get two sets of observations. Inference
+on the parameters can be performed jointly."""
 
 
 def infer_parameters():
@@ -20,7 +22,8 @@ def infer_parameters():
                   4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748,
                   3.8668863066511303, 3.8837108501541007]
 
-    # The prior information changing the class size and the teacher student ratio, depending on the yearly budget of the school 
+    # The prior information changing the class size and the teacher student ratio, depending on the yearly budget of
+    # the school
     from abcpy.continuousmodels import Uniform, Normal
     school_budget = Uniform([[1], [10]], name='school_budget')
 
@@ -74,7 +77,7 @@ def infer_parameters():
 
     # Define a perturbation kernel
     from abcpy.perturbationkernel import DefaultKernel
-    kernel = DefaultKernel([school_budget, class_size, grade_without_additional_effects, \
+    kernel = DefaultKernel([school_budget, class_size, grade_without_additional_effects,
                             no_teacher, scholarship_without_additional_effects])
 
     # Define sampling parameters
@@ -82,15 +85,16 @@ def infer_parameters():
     eps_arr = np.array([.75])
     epsilon_percentile = 10
 
-    # Define sampler
+    # Define sampler; note here how the two models are passed in a list, as well as the two corresponding distance
+    # calculators
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([final_grade, final_scholarship], \
+    sampler = PMCABC([final_grade, final_scholarship],
                      [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel)
 
-    # Sample
-    journal = sampler.sample([grades_obs, scholarship_obs], \
+    # Sample; again, here we pass the two observations in a list
+    journal = sampler.sample([grades_obs, scholarship_obs],
                              T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
-
+    return journal
 
 def analyse_journal(journal):
     # output parameters and weights
diff --git a/examples/modelselection/randomforest_modelselections.py b/examples/modelselection/randomforest_modelselections.py
index b66a76d8..152534cc 100644
--- a/examples/modelselection/randomforest_modelselections.py
+++ b/examples/modelselection/randomforest_modelselections.py
@@ -5,7 +5,7 @@ def infer_model():
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176]
 
-    ## Create a array of models
+    # Create a array of models
     from abcpy.continuousmodels import Uniform, Normal, StudentT
     model_array = [None] * 2
 
@@ -35,3 +35,9 @@ def infer_model():
 
     # Compute the posterior probability of each of the models
     model_prob = modelselection.posterior_probability(y_obs)
+
+    return model, model_prob
+
+if __name__ == "__main__":
+    model, model_prob = infer_model()
+    print(f"The correct model is {model.name} with estimated posterior probability {model_prob[0]}.")

From a88fae9a9ee034999ab2eb3f757b941339b1d9e0 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 12:16:09 +0200
Subject: [PATCH 035/106] Small fix

---
 abcpy/modelselections.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/abcpy/modelselections.py b/abcpy/modelselections.py
index 3f3bac5b..0aa9b4c5 100644
--- a/abcpy/modelselections.py
+++ b/abcpy/modelselections.py
@@ -143,7 +143,7 @@ def select_model(self, observations, n_samples=1000, n_samples_per_param=1):
         self.observations_bds = self.backend.broadcast(observations)
 
         # Creation of reference table
-        if self.reference_table_calculated is 0:
+        if self.reference_table_calculated == 0:
             # Simulating the data, distance and statistics
             seed_arr = self.rng.randint(1, n_samples * n_samples, size=n_samples, dtype=np.int32)
             seed_pds = self.backend.parallelize(seed_arr)
@@ -188,7 +188,7 @@ def posterior_probability(self, observations, n_samples=1000, n_samples_per_para
         self.n_samples_per_param = 1
         self.observations_bds = self.backend.broadcast(observations)
         # Creation of reference table
-        if self.reference_table_calculated is 0:
+        if self.reference_table_calculated == 0:
             # Simulating the data, distance and statistics
             seed_arr = self.rng.randint(1, n_samples * n_samples, size=n_samples, dtype=np.int32)
             seed_pds = self.backend.parallelize(seed_arr)

From faada085d740175a8891a4dc9edb36aea204d934 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 14:38:26 +0200
Subject: [PATCH 036/106] Fix documentation

---
 abcpy/statistics.py               |  1 +
 doc/source/parallelization.rst    |  8 +++----
 doc/source/postanalysis.rst       | 10 ++++----
 doc/source/user_customization.rst | 38 +++++++++++++++----------------
 4 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/abcpy/statistics.py b/abcpy/statistics.py
index 6f2474c1..7d4a7179 100644
--- a/abcpy/statistics.py
+++ b/abcpy/statistics.py
@@ -353,6 +353,7 @@ def save_net(self, path_to_net_state_dict, path_to_scaler=None):
         """Method to save the neural network state dict to a file. If the network is of the class ScalerAndNet, ie a
         scaler is applied before the data is fed through the network, then you are required to pass the path where you
         want the scaler to be saved.
+
         Parameters
         ----------
         path_to_net_state_dict: basestring
diff --git a/doc/source/parallelization.rst b/doc/source/parallelization.rst
index 042ed819..c433e37d 100644
--- a/doc/source/parallelization.rst
+++ b/doc/source/parallelization.rst
@@ -19,7 +19,7 @@ be changed to
 
 .. literalinclude:: ../../examples/backends/mpi/pmcabc_gaussian.py
     :language: python
-    :lines: 6-10
+    :lines: 7-11
     :dedent: 4
 
 In words, one only needs to initialize an instance of the MPI backend. The
@@ -60,7 +60,7 @@ can be passed at the initialization of the backend as follows:
 
 .. literalinclude:: ../../examples/backends/mpi/mpi_model_inferences.py
     :language: python
-    :lines: 10-11
+    :lines: 12-13
     :dedent: 4
 
 Here each model is assigned a MPI communicator with 2 ranks. Clearly, the MPI
@@ -78,7 +78,7 @@ The `forward_simulation` function of the above model is as follows:
 
 .. literalinclude:: ../../examples/backends/mpi/mpi_model_inferences.py
     :language: python
-    :lines: 48-77
+    :lines: 51-80
     :dedent: 4
 
 Note that in order to run jobs in parallel you need to have MPI installed on the
@@ -101,7 +101,7 @@ backend have to be changed to
 
 .. literalinclude:: ../../examples/backends/apache_spark/pmcabc_gaussian.py
     :language: python
-    :lines: 6-9
+    :lines: 7-10
     :dedent: 4
 
 In words, a Spark context has to be created and passed to the Spark
diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst
index 2b48e283..91bbb1f8 100644
--- a/doc/source/postanalysis.rst
+++ b/doc/source/postanalysis.rst
@@ -12,7 +12,7 @@ weights using:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 48-49
+    :lines: 60-61
     :dedent: 4
 
 The output of `get_parameters()` is a Python dictionary. The keys for this dictionary are the names you specified for the parameters. The corresponding values are the marginal posterior samples of that parameter. Here is a short example of what you would specify, and what would be the output in the end:
@@ -45,7 +45,7 @@ For the post analysis basic functions are provided:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 51-54
+    :lines: 63-66
     :dedent: 4
 
 Also, to ensure reproducibility, every journal stores the parameters of the
@@ -53,14 +53,14 @@ algorithm that created it:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 57
+    :lines: 69
     :dedent: 4
 
 Finally, you can plot the inferred posterior mean of the parameters in the following way:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 65
+    :lines: 77
     :dedent: 4
 
 The above line plots the posterior distribution for all the parameters; if you instead want to plot it for some
@@ -77,5 +77,5 @@ And certainly, a journal can easily be saved to and loaded from disk:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 60, 63
+    :lines: 72, 75
     :dedent: 4
diff --git a/doc/source/user_customization.rst b/doc/source/user_customization.rst
index 887880ba..2bcf1f76 100644
--- a/doc/source/user_customization.rst
+++ b/doc/source/user_customization.rst
@@ -54,7 +54,7 @@ Since a Gaussian model generates continous numbers, the newly implemented class
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
    :language: python
-   :lines: 6, 10
+   :lines: 6, 11
 
 A good way to start implementing a new model is to define a convenient way to initialize it with its input parameters.
 In ABCpy all input parameters are either independent ProbabilisticModels or Hyperparameters. Thus, they should not be
@@ -74,7 +74,7 @@ the super class. This leads to the following implementation:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 15-24
+    :lines: 16-25
     :dedent: 4
     :linenos:
 
@@ -144,7 +144,7 @@ A proper implementation look as follows:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 53-63
+    :lines: 50-60
     :dedent: 4
     :linenos:
 
@@ -171,7 +171,7 @@ Then, this function should return :code:`False` as soon as values are out of the
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 41-46
+    :lines: 40-45
     :dedent: 4
     :linenos:
 
@@ -192,7 +192,7 @@ Since our model generates a single float number in one forward simulation, the i
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 49-50
+    :lines: 47-48
     :dedent: 4
     :linenos:
 
@@ -215,7 +215,7 @@ as follows:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 66-71
+    :lines: 62-66
     :dedent: 4
     :linenos:
 
@@ -298,7 +298,7 @@ can write a Python model which uses our C++ code:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
    :language: python
-   :lines: 3 - 60
+   :lines: 1,4,6,8-62
    :linenos:
 
 The important lines are where we import the wrapper code as a module (line 3) and call
@@ -328,17 +328,17 @@ within ABCpy we include the following code at the beginning of our Python file:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_R/gaussian_model.py
     :language: python
-    :lines: 6 - 14
+    :lines: 4-5, 9-15
     :linenos:
 
 This imports the R function :code:`simple_gaussian` into the Python environment.
 We need to build our own model to incorporate this R function as in the previous
 section. The only difference is in the :code:`forward_simulate` method of the
-class :code:`Gaussian'.
+class :code:`Gaussian`.
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_R/gaussian_model.py
     :language: python
-    :lines: 59
+    :lines: 61
     :dedent: 8
     :linenos:
 
@@ -367,7 +367,7 @@ calculator should be provided. The following header conforms to this idea:
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 113-120
+    :lines: 112-119
     :dedent: 4
 
 Then, we need to define how the distance is calculated. First we compute the summary statistics from the datasets and
@@ -379,14 +379,14 @@ to save computation time of summary statistics from observed data, we save the s
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 122-156
+    :lines: 121-155
     :dedent: 4
 
 Finally, we need to define the maximal distance that can be obtained from this distance measure. 
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 159-160
+    :lines: 158-159
     :dedent: 4
 
 The newly defined distance class can be used in the same way as the already existing once. The complete example for this
@@ -410,13 +410,13 @@ implemented:
 
 .. literalinclude:: ../../abcpy/perturbationkernel.py
     :language: python
-    :lines: 101
+    :lines: 98
 
 On the other hand, if the kernel is a discrete kernel, we would need the following method:
 
 .. literalinclude:: ../../abcpy/perturbationkernel.py
     :language: python
-    :lines: 109
+    :lines: 106
 
 As an example, we will implement a kernel which perturbs continuous parameters using a multivariate normal
 distribution (which is already implemented within ABCpy). First, we need to define a constructor.
@@ -430,7 +430,7 @@ this kernel. All these models should be saved on the kernel for future reference
 
 .. literalinclude:: ../../examples/extensions/perturbationkernels/multivariate_normal_kernel.py
     :language: python
-    :lines: 5, 7,8
+    :lines: 7,10-11
 
 Next, we need the following method:
 
@@ -457,7 +457,7 @@ Let us now look at the implementation of the method:
 
 .. literalinclude:: ../../abcpy/perturbationkernel.py
     :language: python
-    :lines: 254-286
+    :lines: 247-279
     :dedent: 4
 
 Some of the implemented inference algorithms weigh different sets of parameters differently. Therefore, if such weights
@@ -486,7 +486,7 @@ Here the implementation for our kernel:
 
 .. literalinclude:: ../../abcpy/perturbationkernel.py
     :language: python
-    :lines: 289-336
+    :lines: 281-329
     :dedent: 4
 
 The first line shows how you obtain the values of the parameters that your kernel should perturb. These values are
@@ -503,7 +503,7 @@ This method is implemented as follows for the multivariate normal:
 
 .. literalinclude:: ../../abcpy/perturbationkernel.py
     :language: python
-    :lines: 339-366
+    :lines: 331-358
     :dedent: 4
 
 We simply obtain the parameter values and covariance matrix for this kernel and calculate the probability density

From b1b297b9621953a0cfe1b8e0534b9b0196e0a7ad Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 12:49:25 +0200
Subject: [PATCH 037/106] Add coverage with codecov

---
 .coveragerc               | 14 ++++++++++++++
 .travis.yml               |  4 ++++
 requirements/coverage.txt |  1 +
 3 files changed, 19 insertions(+)
 create mode 100644 .coveragerc
 create mode 100644 requirements/coverage.txt

diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 00000000..b40172e8
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,14 @@
+[run]
+branch = True
+source = abcpy
+
+[report]
+exclude_lines =
+    if self.debug:
+    pragma: no cover
+    raise NotImplementedError
+    if __name__ == .__main__.:
+    if False:
+ignore_errors = True
+omit =
+    tests/*
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index de8cf030..842104e1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,8 +19,12 @@ install:
 - pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
 - pip install -r requirements/optional-requirements.txt
+- pip install -r requirements/coverage.txt
 script:
 - make test
+- make coveragetest
+after_success:
+- bash <(curl -s https://codecov.io/bash)
 before_deploy:
 - make clean
 - mkdir dist
diff --git a/requirements/coverage.txt b/requirements/coverage.txt
new file mode 100644
index 00000000..15f1c729
--- /dev/null
+++ b/requirements/coverage.txt
@@ -0,0 +1 @@
+codecov

From b20e9808feeb487aab44b15fe99d741bcafe53fc Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 18:25:56 +0200
Subject: [PATCH 038/106] Add badge in README.md

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c9c2e70c..0bc1d843 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
-# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy)
+# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy)
+
 
 ABCpy is a scientific library written in Python for Bayesian uncertainty quantification in
 absence of likelihood function, which parallelizes existing approximate Bayesian computation (ABC) 

From d9fadcab44e85f61ba4d02834c738be8085eae80 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 23 Oct 2020 18:26:53 +0200
Subject: [PATCH 039/106] Do not test twice in travis

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 842104e1..c7f85e0f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -21,7 +21,7 @@ install:
 - pip install -r requirements/optional-requirements.txt
 - pip install -r requirements/coverage.txt
 script:
-- make test
+# - make test
 - make coveragetest
 after_success:
 - bash <(curl -s https://codecov.io/bash)

From 5c87d58136a9b8290f7462c68f193e2f61461b09 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 17:32:42 +0200
Subject: [PATCH 040/106] Update to travis testing: test with/without torch,
 run coverage only if using torch.

---
 .coveragerc |  2 ++
 .travis.yml | 18 ++++++++++++++----
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/.coveragerc b/.coveragerc
index b40172e8..97f1c7dc 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -9,6 +9,8 @@ exclude_lines =
     raise NotImplementedError
     if __name__ == .__main__.:
     if False:
+    except ImportError:
+    if not has_torch:
 ignore_errors = True
 omit =
     tests/*
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index c7f85e0f..c149e87d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,17 +14,27 @@ addons:
     - swig
     - libmpich-dev
     - mpich
+matrix:
+    # Always put true env variable first, for nicer overview on travis website
+    include:
+        - env:
+            - COVER=true
+            - PYTORCH=true
+        - env:
+            - COVER=false
+            - PYTORCH=false
+
 install:
 - pip install -r requirements.txt
 - pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
-- pip install -r requirements/optional-requirements.txt
+- if [[ $PYTORCH == true ]]; then pip install -r requirements/optional-requirements.txt; fi;
 - pip install -r requirements/coverage.txt
 script:
-# - make test
-- make coveragetest
+- make test
+- if [[ $COVER == true ]]; then make coveragetest; fi;
 after_success:
-- bash <(curl -s https://codecov.io/bash)
+- if [[ $COVER == true ]]; then bash <(curl -s https://codecov.io/bash); fi;
 before_deploy:
 - make clean
 - mkdir dist

From 96f5805465ff0133aa2afa6810865baa227e85e8 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 17:52:07 +0200
Subject: [PATCH 041/106] Fix issue with import

---
 abcpy/statisticslearning.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 3311b7a5..710f32e1 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -5,7 +5,6 @@
 from sklearn import linear_model
 from sklearn.preprocessing import MinMaxScaler
 
-from abcpy.NN_utilities.networks import ScalerAndNet
 from abcpy.acceptedparametersmanager import *
 from abcpy.graphtools import GraphTools
 # import dataset and networks definition:
@@ -18,7 +17,7 @@
     has_torch = False
 else:
     has_torch = True
-    from abcpy.NN_utilities.networks import createDefaultNN
+    from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet
     from abcpy.statistics import NeuralEmbedding
 
 from abcpy.NN_utilities.algorithms import FP_nn_training, triplet_training, contrastive_training

From 5778c863cad13d8e2adbbd237ec2d10fdabcfc45 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 17:53:47 +0200
Subject: [PATCH 042/106] Add testing with different python versions

---
 .travis.yml | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index c149e87d..973c4c65 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,5 @@
 dist: xenial
 language: python
-python:
-- '3.7'
 addons:
   apt:
     sources:
@@ -15,26 +13,33 @@ addons:
     - libmpich-dev
     - mpich
 matrix:
-    # Always put true env variable first, for nicer overview on travis website
     include:
-        - env:
-            - COVER=true
-            - PYTORCH=true
-        - env:
-            - COVER=false
-            - PYTORCH=false
+        # Unit tests on different python versions, all on Ubuntu
+        - python: "3.5"
+        - python: "3.6"
+        - python: "3.7"
+        - python: "3.8"
+        - python: "3.9"
+
+      # Test coverage and without Pytorch for a single version
+        - python: "3.8"
+          env:
+            - COVERAGE=true
+        - python: "3.8"
+          env:
+            - NO_PYTORCH=true
 
 install:
 - pip install -r requirements.txt
 - pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
-- if [[ $PYTORCH == true ]]; then pip install -r requirements/optional-requirements.txt; fi;
-- pip install -r requirements/coverage.txt
+- if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/optional-requirements.txt; fi;
+- if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/coverage.txt; fi;
 script:
 - make test
-- if [[ $COVER == true ]]; then make coveragetest; fi;
+- if [[ $COVERAGE == true ]]; then make coveragetest; fi;
 after_success:
-- if [[ $COVER == true ]]; then bash <(curl -s https://codecov.io/bash); fi;
+- if [[ $COVERAGE == true ]]; then bash <(curl -s https://codecov.io/bash); fi;
 before_deploy:
 - make clean
 - mkdir dist

From 7a89ba7e877d9aa72a1474f108fa55f53b7952a1 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 17:56:16 +0200
Subject: [PATCH 043/106] Small fix to show Python version

---
 .travis.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 973c4c65..eac80e05 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -35,6 +35,8 @@ install:
 - pip install -r requirements/backend-spark.txt
 - if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/optional-requirements.txt; fi;
 - if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/coverage.txt; fi;
+before_script:
+- python --version
 script:
 - make test
 - if [[ $COVERAGE == true ]]; then make coveragetest; fi;

From 701621b22acf42f487f7b68140ebc1a4764744c5 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 18:42:04 +0200
Subject: [PATCH 044/106] Fix Python3 versions (3.5 not working with sklearn
 0.23.1 and 3.9 not yet available on travis).

---
 .travis.yml | 2 --
 setup.py    | 5 +++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index eac80e05..d35e9fbb 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,11 +15,9 @@ addons:
 matrix:
     include:
         # Unit tests on different python versions, all on Ubuntu
-        - python: "3.5"
         - python: "3.6"
         - python: "3.7"
         - python: "3.8"
-        - python: "3.9"
 
       # Test coverage and without Pytorch for a single version
         - python: "3.8"
diff --git a/setup.py b/setup.py
index 1b4ad955..8e980787 100644
--- a/setup.py
+++ b/setup.py
@@ -56,8 +56,9 @@
         'Development Status :: 4 - Beta',
 
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
     ],
 
     # What does your project relate to?

From 12e8d166dc2582281ee38718c55b280a75086955 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 18:42:21 +0200
Subject: [PATCH 045/106] Improve README.md

---
 README.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 0bc1d843..9d61a5a2 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy)
+# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy) [![DOI](https://zenodo.org/badge/doi/10.1145/3093172.3093233.svg)](http://dx.doi.org/10.1145/3093172.3093233) [![GitHub license](https://img.shields.io/github/license/eth-cscs/abcpy.svg)](https://github.com/eth-cscs/abcpy/blob/master/LICENSE)
 
 
 ABCpy is a scientific library written in Python for Bayesian uncertainty quantification in
@@ -54,11 +54,9 @@ finally CSCS (Swiss National Super Computing Center) for their generous support.
 
 ## Citation
 
-There is a paper in the proceedings of the 2017 PASC conference. In case you use
+There is a [paper](http://dx.doi.org/10.1145/3093172.3093233) in the proceedings of the 2017 PASC conference. In case you use
 ABCpy for your publication, we would appreciate a citation. You can use
-[this](https://github.com/eth-cscs/abcpy/blob/v0.5.6/doc/literature/DuttaS-ABCpy-PASC-2017.bib)
-
-BibTex reference.
+[this](https://github.com/eth-cscs/abcpy/blob/v0.5.6/doc/literature/DuttaS-ABCpy-PASC-2017.bib) BibTex reference.
 
 
 ## Other Refernces

From 6192b56e2286a124a6c273dd709a2bb892abd624 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 24 Oct 2020 22:56:38 +0200
Subject: [PATCH 046/106] Improve testing with different distributions: do not
 run tests twice when doing coverage

---
 .travis.yml | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index d35e9fbb..8bfecc9c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,8 +16,14 @@ matrix:
     include:
         # Unit tests on different python versions, all on Ubuntu
         - python: "3.6"
+          env:
+            - UNIT_TEST=true
         - python: "3.7"
+          env:
+            - UNIT_TEST=true
         - python: "3.8"
+          env:
+            - UNIT_TEST=true
 
       # Test coverage and without Pytorch for a single version
         - python: "3.8"
@@ -32,11 +38,11 @@ install:
 - pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
 - if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/optional-requirements.txt; fi;
-- if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/coverage.txt; fi;
+- if [[ $COVERAGE == true ]]; then pip install -r requirements/coverage.txt; fi;
 before_script:
 - python --version
 script:
-- make test
+- if [[ $UNIT_TEST == true ]]; then make test; fi;
 - if [[ $COVERAGE == true ]]; then make coveragetest; fi;
 after_success:
 - if [[ $COVERAGE == true ]]; then bash <(curl -s https://codecov.io/bash); fi;

From 08f94cba005336bcb2ed60755c391a41241862df Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 14:52:41 +0100
Subject: [PATCH 047/106] Correct SynLikelihood to work with more than one
 single observation

---
 abcpy/approx_lhd.py       | 17 ++++++++++----
 tests/approx_lhd_tests.py | 48 +++++++++++++++++++++++++++------------
 2 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 6749c70f..921778b0 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -97,10 +97,19 @@ def likelihood(self, y_obs, y_sim):
         robust_precision_sim = np.linalg.inv(lw_cov_)
         robust_precision_sim_det = np.linalg.det(robust_precision_sim)
         # print("DEBUG: combining.")
-        tmp1 = robust_precision_sim * np.array(self.stat_obs.reshape(-1, 1) - mean_sim.reshape(-1, 1)).T
-        tmp2 = np.exp(np.sum(-0.5 * np.sum(np.array(self.stat_obs - mean_sim) * np.array(tmp1).T, axis=1)))
-        tmp3 = pow(np.sqrt((1 / (2 * np.pi)) * robust_precision_sim_det), self.stat_obs.shape[0])
-        return tmp2 * tmp3
+        # we may have different observation; loop on those now:
+        # likelihoods = np.zeros(self.stat_obs.shape[0])
+        # for i, single_stat_obs in enumerate(self.stat_obs):
+        #     x_new = np.einsum('i,ij,j->', single_stat_obs - mean_sim, robust_precision_sim, single_stat_obs - mean_sim)
+        #     likelihoods[i] = np.exp(-0.5 * x_new)
+        # do without for loop:
+        diff = self.stat_obs - mean_sim.reshape(1,-1)
+        x_news = np.einsum('bi,ij,bj->b', diff, robust_precision_sim, diff)
+        likelihoods = np.exp(-0.5 * x_news)
+        # looks like we are exponentiating the determinant as well, which is wrong;
+        # this is however a constant which should not change the algorithms afterwards.
+        factor = pow(np.sqrt((1 / (2 * np.pi)) * robust_precision_sim_det), self.stat_obs.shape[0])
+        return np.prod(likelihoods) * factor  # compute the product of the different likelihoods for each observation
 
 
 class PenLogReg(Approx_likelihood, GraphTools):
diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index d1b09651..3e11f336 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -20,6 +20,12 @@ def setUp(self):
                                             seed=1)
         self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10,
                                           max_iter=100000, seed=1)
+        # create fake simulated data
+        self.mu._fixed_values = [1.1]
+        self.sigma._fixed_values = [1.0]
+        self.y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
+        self.y_sim_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 100,
+                                                                     rng=np.random.RandomState(1))
 
     def test_likelihood(self):
         # Checks whether wrong input type produces error message
@@ -28,11 +34,7 @@ def test_likelihood(self):
 
         # create observed data
         y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))
-        # create fake simulated data
-        self.mu._fixed_values = [1.1]
-        self.sigma._fixed_values = [1.0]
-        y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
-        comp_likelihood = self.likfun.likelihood(y_obs, y_sim)
+        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
         expected_likelihood = 9.77317308598673e-08
         # This checks whether it computes a correct value and dimension is right. Not correct as it does not check the
         # absolute value:
@@ -40,17 +42,27 @@ def test_likelihood(self):
         self.assertAlmostEqual(comp_likelihood, expected_likelihood)
 
         # check if it returns the correct error when n_samples does not match:
-        self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.likelihood, y_obs, y_sim)
+        self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.likelihood, y_obs, self.y_sim)
 
         # try now with the bivariate uniform model:
         y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1,
                                                                 rng=np.random.RandomState(1))
-        y_sim_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 100,
-                                                                rng=np.random.RandomState(1))
-        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, y_sim_bivariate)
+        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, self.y_sim_bivariate)
         expected_likelihood_biv = 0.999999999999999
         self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
 
+    def test_likelihood_multiple_observations(self):
+        y_obs = self.model.forward_simulate(self.model.get_input_values(), 2, rng=np.random.RandomState(1))
+        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
+        expected_likelihood = 6.547737649959798
+        self.assertAlmostEqual(comp_likelihood, expected_likelihood)
+
+        y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 2,
+                                                                rng=np.random.RandomState(1))
+        expected_likelihood_biv = 0.9999999999999979
+        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, self.y_sim_bivariate)
+        self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
+
 
 class SynLikelihoodTests(unittest.TestCase):
     def setUp(self):
@@ -59,6 +71,10 @@ def setUp(self):
         self.model = Normal([self.mu, self.sigma])
         self.stat_calc = Identity(degree=2, cross=False)
         self.likfun = SynLikelihood(self.stat_calc)
+        # create fake simulated data
+        self.mu._fixed_values = [1.1]
+        self.sigma._fixed_values = [1.0]
+        self.y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
 
     def test_likelihood(self):
         # Checks whether wrong input type produces error message
@@ -67,16 +83,20 @@ def test_likelihood(self):
 
         # create observed data
         y_obs = [1.8]
-        # create fake simulated data
-        self.mu._fixed_values = [1.1]
-        self.sigma._fixed_values = [1.0]
-        y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
         # calculate the statistics of the observed data
-        comp_likelihood = self.likfun.likelihood(y_obs, y_sim)
+        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
         expected_likelihood = 0.20963610211945238
         # This checks whether it computes a correct value and dimension is right
         self.assertAlmostEqual(comp_likelihood, expected_likelihood)
 
+    def test_likelihood_multiple_observations(self):
+        y_obs = [1.8, 0.9]
+        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
+        print(comp_likelihood)
+        expected_likelihood = 0.04457899184856649
+        # This checks whether it computes a correct value and dimension is right
+        self.assertAlmostEqual(comp_likelihood, expected_likelihood)
+
 
 if __name__ == '__main__':
     unittest.main()

From e8dd78414053f8b20791887dc62ff007e2726ebf Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 27 Oct 2020 16:49:12 +0100
Subject: [PATCH 048/106] Correct examples

---
 .../approx_lhd/pmc_hierarchical_models.py     | 21 ++--
 examples/backends/README.md                   | 57 +++++++++++
 .../backends/apache_spark/pmcabc_gaussian.py  | 44 +++++----
 examples/backends/dummy/pmcabc_gaussian.py    | 43 ++++----
 examples/backends/mpi/mpi_model_inferences.py | 83 ++++++++--------
 examples/backends/mpi/pmcabc_gaussian.py      | 62 ++++++------
 .../extensions/distances/default_distance.py  |  2 +-
 examples/extensions/models/README.md          | 53 ++++++++++
 ...del.py => pmcabc-gaussian_model_simple.py} | 19 ++--
 .../extensions/models/gaussian_cpp/Makefile   |  6 +-
 .../pmcabc-gaussian_model_simple.py           | 19 ++--
 .../pmcabc-gaussian_model_simple.py           | 99 +++++++++++++------
 ...ple.py => pmcabc-gaussian_model_simple.py} | 31 +++---
 .../multivariate_normal_kernel.py             | 71 +++++++++----
 .../pmcabc_perturbation_kernels.py            | 35 +++++--
 ...mcabc_inference_on_multiple_sets_of_obs.py | 23 +++--
 .../randomforest_modelselections.py           |  4 +-
 .../pmcabc_gaussian_statistics_learning.py    | 19 +++-
 18 files changed, 471 insertions(+), 220 deletions(-)
 create mode 100644 examples/backends/README.md
 create mode 100644 examples/extensions/models/README.md
 rename examples/extensions/models/gaussian_R/{gaussian_model.py => pmcabc-gaussian_model_simple.py} (91%)
 rename examples/extensions/models/gaussian_python/{pmcabc_gaussian_model_simple.py => pmcabc-gaussian_model_simple.py} (88%)

diff --git a/examples/approx_lhd/pmc_hierarchical_models.py b/examples/approx_lhd/pmc_hierarchical_models.py
index 8798dbae..477643ca 100644
--- a/examples/approx_lhd/pmc_hierarchical_models.py
+++ b/examples/approx_lhd/pmc_hierarchical_models.py
@@ -1,5 +1,8 @@
 """An example showing how to implement a bayesian network in ABCpy. We consider here a model of school grades which
 depend on some variables."""
+import logging
+
+logging.basicConfig(level=logging.INFO)
 
 
 def infer_parameters():
@@ -21,16 +24,16 @@ def infer_parameters():
 
     # The prior information changing the class size and social background, depending on school location
     from abcpy.continuousmodels import Uniform, Normal
-    school_location = Uniform([[0.2], [0.3]], )
+    school_location = Uniform([[0.2], [0.3]], name="school_location")
 
     # The average class size of a certain school
-    class_size = Normal([[school_location], [0.1]], )
+    class_size = Normal([[school_location], [0.1]], name="class_size")
 
     # The social background of a student
-    background = Normal([[school_location], [0.1]], )
+    background = Normal([[school_location], [0.1]], name="background")
 
     # The grade a student would receive without any bias
-    grade_without_additional_effects = Normal([[4.5], [0.25]], )
+    grade_without_additional_effects = Normal([[4.5], [0.25]], name="grade_without_additional_effects")
 
     # The grade a student of a certain school receives; this defined a new random variable by subtraction
     final_grade = grade_without_additional_effects - class_size - background
@@ -52,7 +55,7 @@ def infer_parameters():
                        1.0893224045062178, 0.8032302688764734, 2.868438615047827]
 
     # A quantity that determines whether a student will receive a scholarship
-    scholarship_without_additional_effects = Normal([[2], [0.5]], )
+    scholarship_without_additional_effects = Normal([[2], [0.5]], name="scholarship_without_additional_effects")
 
     # A quantity determining whether a student receives a scholarship, including his social background
     final_scholarship = scholarship_without_additional_effects + 3 * background
@@ -77,7 +80,7 @@ def infer_parameters():
                             background, scholarship_without_additional_effects])
 
     # Define sampling parameters
-    T, n_sample, n_samples_per_param = 3, 250, 10
+    T, n_sample, n_samples_per_param = 3, 250, 20
 
     # Define sampler to use with the
     from abcpy.inferences import PMC
@@ -88,9 +91,10 @@ def infer_parameters():
     journal = sampler.sample([grades_obs, scholarship_obs], T, n_sample, n_samples_per_param)
     return journal
 
+
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.get_stored_output_values())
+    print(journal.get_parameters())
     print(journal.weights)
 
     # do post analysis
@@ -101,6 +105,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/backends/README.md b/examples/backends/README.md
new file mode 100644
index 00000000..2659d4c5
--- /dev/null
+++ b/examples/backends/README.md
@@ -0,0 +1,57 @@
+# Parallelization Backends  
+We showcase here how to use the different parallelization backends with the same inference problem. See [here](https://abcpy.readthedocs.io/en/latest/parallelization.html#) for more information.
+
+## Apache Spark
+
+This uses the Apache Spark backend for parallelization. It relies on the `pyspark` and `findspark` library. 
+
+In this setup, the number of parallel processes is defined inside the Python code, with the following lines:
+
+    import pyspark
+    sc = pyspark.SparkContext()
+    from abcpy.backends import BackendSpark as Backend
+    backend = Backend(sc, parallelism=4)
+
+Then, the parallel script can be run with: 
+
+    PYSPARK_PYTHON=python3 spark-submit pmcabc_gaussian.py 
+
+where the environment variable `PYSPARK_PYTHON` is set as often Spark installations use Python2 by default.    
+
+
+## Dummy
+
+This is a dummy backend which does not parallelize; it is useful for debug and testing purposes. Simply run the Python file as normal.
+
+## MPI
+
+This used MPI to distribute the inference task; we exploit the `mpi4py` Python library for using MPI from Python.
+
+Mainly, we distribute data generation from the model, which is usually the most expensive part in ABC inference. 
+
+We have two files in `mpi` folder:
+1. `pmcabc_gaussian.py` performs a simple inference experiment on a gaussian model with PMCABC; this is the same as in the other two backends
+2. `mpi_model_inferences.py` showcases how to use nested MPI parallelization with a model which already has some level of parallelization with MPI. That is done with several ABC algorithms. See below to understand how to run this file correctly.
+
+To run the files with MPI, the following command is required:
+
+    mpirun -n <n_tasks> python3 <filename.py>
+
+For instance, to run `pmcabc_gaussian.py` with 4 tasks, we can run: 
+
+    mpirun -n 4 python3 pmcabc_gaussian.py
+
+### Nested parallelization with MPI
+
+In `mpi_model_inferences.py`, the model itself is parallelized with MPI. We can run nested parallelized inference by considering _n_ independent model instances (ie we simulate _n_ independent copies of the model at once) each of which is assigned _m_ MPI tasks. Moreover, we also require one additional MPI task to work as a master in this setup. Therefore, in total we need _(n * m) + 1_ MPI tasks. In this case, we have set _m=2_ in the Python code via the lines: 
+
+```
+from abcpy.backends import BackendMPI as Backend
+backend = Backend(process_per_model=2)
+```
+
+Let's say we want to parallelize the model _n=3_ times. Therefore, we use the following command:
+
+    mpirun -n 7 python3 mpi_model_inferences.py
+
+as _(3*2) + 1 = 7_. Note that, in this scenario, using only 6 tasks overall leads to failure of the script due to how the tasks are assigned to the model instances.  
diff --git a/examples/backends/apache_spark/pmcabc_gaussian.py b/examples/backends/apache_spark/pmcabc_gaussian.py
index eac5994c..1c377be9 100644
--- a/examples/backends/apache_spark/pmcabc_gaussian.py
+++ b/examples/backends/apache_spark/pmcabc_gaussian.py
@@ -1,5 +1,9 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
 
 def setup_backend():
     global backend
@@ -12,26 +16,27 @@ def setup_backend():
 
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
-             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
-             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
-             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
-             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
-             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
-             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
-             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
-             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
-             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
-             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
-             202.67075179617672, 211.75963110985992, 217.45423324370509]
+    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+                  172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+                  183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+                  197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+                  165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537,
+                  206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275,
+                  171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235,
+                  197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519,
+                  185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741,
+                  250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021,
+                  138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626,
+                  188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    prior = Uniform([[150, 5], [200, 25]], )
+    mu = Uniform([[150], [200]], name='mu')
+    sigma = Uniform([[5], [25]], name='sigma')
 
     # define the model
     from abcpy.continuousmodels import Normal
-    model = Normal([prior], )
+    height = Normal([mu, sigma], name='height')
 
     # define statistics
     from abcpy.statistics import Identity
@@ -43,21 +48,21 @@ def infer_parameters():
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([model], distance_calculator, backend, seed=1)
+    sampler = PMCABC([height], [distance_calculator], backend, seed=1)
 
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -67,6 +72,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/backends/dummy/pmcabc_gaussian.py b/examples/backends/dummy/pmcabc_gaussian.py
index 45016f69..5d82b96f 100644
--- a/examples/backends/dummy/pmcabc_gaussian.py
+++ b/examples/backends/dummy/pmcabc_gaussian.py
@@ -1,5 +1,9 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
 
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
@@ -18,12 +22,12 @@ def infer_parameters():
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu = Uniform([[150], [200]], )
-    sigma = Uniform([[5], [25]], )
+    mu = Uniform([[150], [200]], name='mu')
+    sigma = Uniform([[5], [25]], name='sigma')
 
     # define the model
     from abcpy.continuousmodels import Normal
-    height = Normal([mu, sigma], )
+    height = Normal([mu, sigma], name='height')
 
     # define statistics
     from abcpy.statistics import Identity
@@ -57,36 +61,37 @@ def infer_parameters():
 
 def analyse_journal(journal):
     # output parameters and weights
-    journal.get_parameters()
-    journal.get_weights()
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
-    journal.posterior_mean()
-    journal.posterior_cov()
-    journal.posterior_histogram()
+    print(journal.posterior_mean())
+    print(journal.posterior_cov())
+    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
     from abcpy.output import Journal
     new_journal = Journal.fromFile('experiments.jnl')
 
-    journal.plot_posterior_distr()
-
 
 # this code is for testing purposes only and not relevant to run the example
-import unittest
-
-
-class ExampleGaussianDummyTest(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 176
-        self.assertLess(abs(test_result - expected_result), 2.)
+# import unittest
+#
+#
+# class ExampleGaussianDummyTest(unittest.TestCase):
+#     def test_example(self):
+#         journal = infer_parameters()
+#         test_result = journal.posterior_mean()[0]
+#         expected_result = 176
+#         self.assertLess(abs(test_result - expected_result), 2.)
 
 
 if __name__ == "__main__":
diff --git a/examples/backends/mpi/mpi_model_inferences.py b/examples/backends/mpi/mpi_model_inferences.py
index e9dc1dd7..584c6224 100644
--- a/examples/backends/mpi/mpi_model_inferences.py
+++ b/examples/backends/mpi/mpi_model_inferences.py
@@ -1,10 +1,11 @@
-# import logging
-# logging.basicConfig(level=logging.DEBUG)
+import logging
 
 import numpy as np
 
 from abcpy.probabilisticmodels import ProbabilisticModel, InputConnector
 
+logging.basicConfig(level=logging.WARNING)
+
 
 def setup_backend():
     global backend
@@ -82,14 +83,13 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState, mpi_comm=
 
 def infer_parameters_pmcabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -108,7 +108,7 @@ def infer_parameters_pmcabc():
     T, n_sample, n_samples_per_param = 2, 10, 1
     eps_arr = np.array([10000])
     epsilon_percentile = 95
-
+    print('PMCABC Inferring')
     journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
@@ -116,14 +116,13 @@ def infer_parameters_pmcabc():
 
 def infer_parameters_abcsubsim():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -137,8 +136,9 @@ def infer_parameters_abcsubsim():
 
     # define sampling scheme
     from abcpy.inferences import ABCsubsim
-    sampler = ABCsubsim([height_weight_model], [distance_calculator], backend)
+    sampler = ABCsubsim([height_weight_model], [distance_calculator], backend, seed=1)
     steps, n_samples, n_samples_per_param, chain_length = 2, 10, 1, 2
+    print('ABCsubsim Inferring')
     journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, chain_length)
 
     return journal
@@ -146,14 +146,13 @@ def infer_parameters_abcsubsim():
 
 def infer_parameters_rsmcabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -168,7 +167,6 @@ def infer_parameters_rsmcabc():
     # define sampling scheme
     from abcpy.inferences import RSMCABC
     sampler = RSMCABC([height_weight_model], [distance_calculator], backend, seed=1)
-    print('sampling')
     steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final = 2, 10, 1, 0.1, 10000, 500
     print('RSMCABC Inferring')
     journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final,
@@ -179,13 +177,13 @@ def infer_parameters_rsmcabc():
 
 def infer_parameters_sabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
 
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
@@ -201,27 +199,24 @@ def infer_parameters_sabc():
     # define sampling scheme
     from abcpy.inferences import SABC
     sampler = SABC([height_weight_model], [distance_calculator], backend, seed=1)
-    print('sampling')
-    steps, epsilon, n_samples, n_samples_per_param, beta, delta, v = 2, np.array([40000]), 10, 1, 2, 0.2, 0.3
-    ar_cutoff, resample, n_update, adaptcov, full_output = 0.1, None, None, 1, 1
-    #
-    # # print('SABC Inferring')
+    steps, epsilon, n_samples, n_samples_per_param, beta, delta, v = 2, 40000, 10, 1, 2, 0.2, 0.3
+    ar_cutoff, resample, n_update, full_output = 0.1, None, None, 1
+    print('SABC Inferring')
     journal = sampler.sample([y_obs], steps, epsilon, n_samples, n_samples_per_param, beta, delta, v, ar_cutoff,
-                             resample, n_update, adaptcov, full_output)
+                             resample, n_update, full_output)
 
     return journal
 
 
 def infer_parameters_apmcabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -237,6 +232,7 @@ def infer_parameters_apmcabc():
     from abcpy.inferences import APMCABC
     sampler = APMCABC([height_weight_model], [distance_calculator], backend, seed=1)
     steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 2, 100, 1, 0.2, 0.03, 2.0, 1, None
+    print('APMCABC Inferring')
     journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor,
                              full_output, journal_file)
 
@@ -245,14 +241,13 @@ def infer_parameters_apmcabc():
 
 def infer_parameters_rejectionabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -268,6 +263,7 @@ def infer_parameters_rejectionabc():
     from abcpy.inferences import RejectionABC
     sampler = RejectionABC([height_weight_model], [distance_calculator], backend, seed=1)
     n_samples, n_samples_per_param, epsilon = 2, 1, 20000
+    print('RejectionABC Inferring')
     journal = sampler.sample([y_obs], n_samples, n_samples_per_param, epsilon)
 
     return journal
@@ -275,14 +271,13 @@ def infer_parameters_rejectionabc():
 
 def infer_parameters_smcabc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -298,6 +293,7 @@ def infer_parameters_smcabc():
     from abcpy.inferences import SMCABC
     sampler = SMCABC([height_weight_model], [distance_calculator], backend, seed=1)
     steps, n_samples, n_samples_per_param, epsilon = 2, 10, 1, 2000
+    print('SMCABC Inferring')
     journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, epsilon, full_output=1)
 
     return journal
@@ -305,14 +301,13 @@ def infer_parameters_smcabc():
 
 def infer_parameters_pmc():
     # define observation for true parameters mean=170, 65
-    rng = np.random.RandomState()
+    rng = np.random.RandomState(seed=1)
     y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))]
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu0 = Uniform([[150], [200]], )
-    mu1 = Uniform([[25], [100]], )
-
+    mu0 = Uniform([[150], [200]], name="mu0")
+    mu1 = Uniform([[25], [100]], name="mu1")
     # define the model
     height_weight_model = NestedBivariateGaussian([mu0, mu1])
 
@@ -325,11 +320,11 @@ def infer_parameters_pmc():
 
     # define sampling scheme
     from abcpy.inferences import PMC
-    sampler = PMC([height_weight_model], [approx_lhd], backend, seed=1)
+    sampler = PMC([height_weight_model], [approx_lhd], backend, seed=2)
 
     # sample from scheme
     T, n_sample, n_samples_per_param = 2, 10, 10
-
+    print('PMC Inferring')
     journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param)
 
     return journal
diff --git a/examples/backends/mpi/pmcabc_gaussian.py b/examples/backends/mpi/pmcabc_gaussian.py
index 9d839c18..9afa300e 100644
--- a/examples/backends/mpi/pmcabc_gaussian.py
+++ b/examples/backends/mpi/pmcabc_gaussian.py
@@ -1,5 +1,9 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
 
 def setup_backend():
     global backend
@@ -13,18 +17,18 @@ def setup_backend():
 
 def infer_parameters():
     # define observation for true parameters mean=170, std=15
-    y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
-             172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
-             183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
-             197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
-             165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766,
-             220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033,
-             210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226,
-             165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586,
-             152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803,
-             148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139,
-             179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822,
-             202.67075179617672, 211.75963110985992, 217.45423324370509]
+    height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
+                  172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
+                  183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515,
+                  197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633,
+                  165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537,
+                  206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275,
+                  171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235,
+                  197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519,
+                  185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741,
+                  250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021,
+                  138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626,
+                  188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
     from abcpy.continuousmodels import Uniform
@@ -40,26 +44,26 @@ def infer_parameters():
     statistics_calculator = Identity(degree=2, cross=False)
 
     # define distance
-    from abcpy.distances import Euclidean
-    distance_calculator = Euclidean(statistics_calculator)
+    from abcpy.distances import LogReg
+    distance_calculator = LogReg(statistics_calculator)
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 2, 10, 1
-    eps_arr = np.array([10000])
-    epsilon_percentile = 95
-    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    T, n_sample, n_samples_per_param = 3, 250, 10
+    eps_arr = np.array([.75])
+    epsilon_percentile = 10
+    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -69,6 +73,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
@@ -76,9 +83,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-import unittest
-
-
 def setUpModule():
     '''
     If an exception is raised in a setUpModule then none of 
@@ -95,12 +99,12 @@ def setUpModule():
     setup_backend()
 
 
-class ExampleGaussianMPITest(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()['mu']
-        expected_result = 171.4343638312893
-        self.assertLess(abs(test_result - expected_result), 2)
+# class ExampleGaussianMPITest(unittest.TestCase):
+#     def test_example(self):
+#         journal = infer_parameters()
+#         test_result = journal.posterior_mean()['mu']
+#         expected_result = 171.4343638312893
+#         self.assertLess(abs(test_result - expected_result), 2)
 
 
 if __name__ == "__main__":
diff --git a/examples/extensions/distances/default_distance.py b/examples/extensions/distances/default_distance.py
index f3eadf17..a9cf6a87 100644
--- a/examples/extensions/distances/default_distance.py
+++ b/examples/extensions/distances/default_distance.py
@@ -5,7 +5,7 @@
 
 class DefaultJointDistance(Distance):
     """
-    This class shocases how to implement a distance. It is actually a wrapper of the Euclidean distance, which is
+    This class showcases how to implement a distance. It is actually a wrapper of the Euclidean distance, which is
     applied on each component of the provided datasets and summed.
 
     Parameters
diff --git a/examples/extensions/models/README.md b/examples/extensions/models/README.md
new file mode 100644
index 00000000..23c9c1af
--- /dev/null
+++ b/examples/extensions/models/README.md
@@ -0,0 +1,53 @@
+# Wrapping models written in external code
+
+In this folder we showcase how to wrap models written in C++, R and FORTRAN. We use the same model in all cases (a simple gaussian one) and we also provide the corresponding Python implementation for the sake of reference.
+
+## C++
+
+We use [Swig](http://www.swig.org/) here to interface C++ with Python. In order to use that, an interface file has to be created correctly, which specifies how to interface C++ with Python. 
+
+Check [here](https://abcpy.readthedocs.io/en/latest/user_customization.html#wrap-a-model-written-in-c) for more detailed explanation. 
+
+### Instructions
+ 
+1. Go inside the `gaussian_cpp` folder.
+2. Run `make` (requires a C++ compiler, eg `g++`). This automatically creates an additional Python file (`gaussian_model_simple.py`) and a compiled file (`_gaussian_model_simple.so`).
+3. Run the `pmcabc-gaussian_model_simple.py` file.
+
+
+### Common issues
+
+You may encounter some issue with the `boost` library which can be solved by installing it and putting it into the correct search path; in Ubuntu, install it with:
+
+```sudo apt-get install  libboost-all-dev```
+
+### Link Time Optimization (LTO):
+
+For more efficient compilation, usually C++ compilers use LTO to link previously compiled libraries to the currently compiled code. That can lead to issues however in this case, if for instance the Python3 executable was compiled with another version of compiler than the one currently installed. For this reason, Makefile here disables LTO by adding the flag `-fno-lto` to the two lines calling the C++ compiler. 
+
+In case your C++ code is large and compilation takes long, you can remove those flags, even if that may break the compilation for the reasons outlined above. 
+
+Check [here](https://github.com/ContinuumIO/anaconda-issues/issues/6619) for more information.
+
+## FORTRAN
+
+We can use easily the [F2PY](https://numpy.org/doc/stable/f2py/) tool to connect FORTRAN code to Python. This is part of Numpy. 
+
+### Instructions
+
+1. Go inside the `gaussian_f90` folder.
+2. Run `make`; (requires a FORTRAN compiler, eg `F90`); this will produce a compiled file.
+3. Run the `pmcabc-gaussian_model_simple.py` file.
+
+## R
+
+We use here the `rpy2` Python package to import R code in Python.
+
+Check [here](https://abcpy.readthedocs.io/en/latest/user_customization.html#wrap-a-model-written-in-r) for more detailed explanation.
+
+### Instructions
+
+This does not require any compilation, as R is not a compiled language. 
+
+1. Go inside the `gaussian_R` folder.
+2. Run the `pmcabc-gaussian_model_simple.py` file, which includes code to import the corresponding R code.
diff --git a/examples/extensions/models/gaussian_R/gaussian_model.py b/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
similarity index 91%
rename from examples/extensions/models/gaussian_R/gaussian_model.py
rename to examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
index b281827d..f40b9105 100644
--- a/examples/extensions/models/gaussian_R/gaussian_model.py
+++ b/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
@@ -1,3 +1,4 @@
+import logging
 from numbers import Number
 
 import numpy as np
@@ -6,6 +7,8 @@
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
+logging.basicConfig(level=logging.INFO)
+
 rpy2.robjects.numpy2ri.activate()
 
 robjects.r('''
@@ -87,11 +90,12 @@ def infer_parameters():
              202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
-    from abcpy.continousmodels import Uniform
-    prior = Uniform([[150, 5], [200, 25]])
+    from abcpy.continuousmodels import Uniform
+    mu = Uniform([[150], [200]], name="mu")
+    sigma = Uniform([[5], [25]], name="sigma")
 
     # define the model
-    model = Gaussian([prior])
+    model = Gaussian([mu, sigma], name='height')
 
     # define statistics
     from abcpy.statistics import Identity
@@ -107,7 +111,7 @@ def infer_parameters():
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([model], distance_calculator, backend)
+    sampler = PMCABC([model], [distance_calculator], backend)
 
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 250, 10
@@ -120,8 +124,8 @@ def infer_parameters():
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -131,6 +135,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/extensions/models/gaussian_cpp/Makefile b/examples/extensions/models/gaussian_cpp/Makefile
index cccf21ff..f8ac53ee 100644
--- a/examples/extensions/models/gaussian_cpp/Makefile
+++ b/examples/extensions/models/gaussian_cpp/Makefile
@@ -12,7 +12,7 @@ PYTHONLIBS=$(shell python3-config --libs)
 cpp_simple: _gaussian_model_simple.so gaussian_model_simple.py
 
 clean:
-	rm gaussian_model_simple.o gaussian_model_simple.py gaussian_model_simple_wrap.cpp
+	rm _gaussian_model_simple.so gaussian_model_simple.py
 
 %.py: %.i
 	$(SWIG) $(SWIGFLAGS) -o $@ $<
@@ -21,10 +21,10 @@ clean:
 	$(SWIG) $(SWIGFLAGS) -o $@ $<
 
 %.o: %.cpp
-	$(CC) $(CPPFLAGS) -I $(INCLUDEPATHNUMPY) $(INCLUDEPATH) -c $< -o $@
+	$(CC) $(CPPFLAGS) -I $(INCLUDEPATHNUMPY) $(INCLUDEPATH) -fno-lto -c $< -o $@
 
 _%.so: %.o %_wrap.o
-	$(CC) -shared $^ $(PYTHONLINKERSETTINGS) $(PYTHONLIBS) -o $@
+	$(CC) -shared $^ $(PYTHONLINKERSETTINGS) $(PYTHONLIBS) -fno-lto -o  $@
 
 %.i:
 	$(WGET) "https://raw.githubusercontent.com/numpy/numpy/master/tools/swig/numpy.i"
diff --git a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
index 00840b1c..20a9dccd 100644
--- a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
@@ -1,10 +1,13 @@
+import logging
 from numbers import Number
 
 import numpy as np
-from gaussian_model_simple import gaussian_model
+from gaussian_model_simple import gaussian_model  # this is the file produced upon compiling
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
+logging.basicConfig(level=logging.INFO)
+
 
 class Gaussian(ProbabilisticModel, Continuous):
 
@@ -49,7 +52,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
         seed = rng.randint(np.iinfo(np.int32).max)
 
         # Do the actual forward simulation
-        vector_of_k_samples = gaussian_model(k, mu, sigma, seed)
+        vector_of_k_samples = gaussian_model(k, mu, sigma, seed)  # call the C++ code
 
         # Format the output to obey API
         result = [np.array([x]) for x in vector_of_k_samples]
@@ -79,10 +82,11 @@ def infer_parameters():
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    prior = Uniform([[150, 5], [200, 25]], )
+    mu = Uniform([[150], [200]], name="mu")
+    sigma = Uniform([[5], [25]], name="sigma")
 
     # define the model
-    model = Gaussian([prior], )
+    model = Gaussian([mu, sigma], name='height')
 
     # define statistics
     from abcpy.statistics import Identity
@@ -111,8 +115,8 @@ def infer_parameters():
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -122,6 +126,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
index 5e57d7ba..8fcc4aef 100644
--- a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
@@ -1,35 +1,67 @@
-import numpy as np
+import logging
+from numbers import Number
 
-from abcpy.models import Model
+import numpy as np
 from gaussian_model_simple import gaussian_model
 
+from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
+
+logging.basicConfig(level=logging.INFO)
+
+
+class Gaussian(ProbabilisticModel, Continuous):
+    def __init__(self, parameters, seed=None, name="gaussian"):
+        if not isinstance(parameters, list):
+            raise TypeError('Input of Normal model is of type list')
+
+        if len(parameters) != 2:
+            raise RuntimeError('Input list must be of length 2, containing [mu, sigma].')
+
+        input_connector = InputConnector.from_list(parameters)
+        super().__init__(input_connector, name)
 
-class Gaussian(Model):
-    def __init__(self, prior, seed=None):
-        self.prior = prior
-        self.sample_from_prior()
-        self.rng = np.random.RandomState(seed)
+    def _check_input(self, input_values):
+        # Check whether input has correct type or format
+        if len(input_values) != 2:
+            raise ValueError('Number of parameters of Normal model must be 2.')
 
-    def set_parameters(self, theta):
-        theta = np.array(theta)
-        if theta.shape[0] > 2: return False
-        if theta[1] <= 0: return False
+        # Check whether input is from correct domain
+        mu = input_values[0]
+        sigma = input_values[1]
+        if sigma < 0:
+            return False
 
-        self.mu = theta[0]
-        self.sigma = theta[1]
         return True
 
-    def get_parameters(self):
-        return np.array([self.mu, self.sigma])
+    def _check_output(self, values):
+        if not isinstance(values, Number):
+            raise ValueError('Output of the normal distribution is always a number.')
 
-    def sample_from_prior(self):
-        sample = self.prior.sample(1, ).reshape(-1)
-        self.set_parameters(sample)
+        # At this point values is a number (int, float); full domain for Normal is allowed
+        return True
+
+    def get_output_dimension(self):
+        return 1
+
+    def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
+        # Extract the input parameters
+        mu = input_values[0]
+        sigma = input_values[1]
+
+        seed = rng.randint(100000)
 
-    def simulate(self, k):
-        seed = self.rng.randint(np.iinfo(np.int32).max)
-        result = gaussian_model(self.mu, self.sigma, k, seed)
-        return list(result)
+        # Do the actual forward simulation
+        vector_of_k_samples = np.array(gaussian_model(mu, sigma, k, seed))
+
+        # Format the output to obey API
+        result = [np.array([x]) for x in vector_of_k_samples]
+        return result
+
+    def pdf(self, input_values, x):
+        mu = input_values[0]
+        sigma = input_values[1]
+        pdf = np.norm(mu, sigma).pdf(x)
+        return pdf
 
 
 def infer_parameters():
@@ -48,11 +80,12 @@ def infer_parameters():
              202.67075179617672, 211.75963110985992, 217.45423324370509]
 
     # define prior
-    from abcpy.distributions import Uniform
-    prior = Uniform([150, 5], [200, 25])
+    from abcpy.continuousmodels import Uniform
+    mu = Uniform([[150], [200]], name="mu")
+    sigma = Uniform([[5], [25]], name="sigma")
 
     # define the model
-    model = Gaussian(prior)
+    model = Gaussian([mu, sigma], name='height')
 
     # define statistics
     from abcpy.statistics import Identity
@@ -63,9 +96,8 @@ def infer_parameters():
     distance_calculator = LogReg(statistics_calculator)
 
     # define kernel
-    from abcpy.distributions import MultiStudentT
-    mean, cov, df = np.array([.0, .0]), np.eye(2), 3.
-    kernel = MultiStudentT(mean, cov, df)
+    from abcpy.perturbationkernel import DefaultKernel
+    kernel = DefaultKernel([mu, sigma])
 
     # define backend
     from abcpy.backends import BackendDummy as Backend
@@ -73,21 +105,21 @@ def infer_parameters():
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
-    sampler = PMCABC(model, distance_calculator, kernel, backend)
+    sampler = PMCABC([model], [distance_calculator], backend, kernel, seed=1)
 
     # sample from scheme
     T, n_sample, n_samples_per_param = 3, 100, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample(y_obs, T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -97,6 +129,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
similarity index 88%
rename from examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
rename to examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
index 7ce44e16..7c2b82a2 100644
--- a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
@@ -10,7 +10,7 @@
 
 class Gaussian(ProbabilisticModel, Continuous):
     """
-    This class is an re-implementation of the `abcpy.continousmodels.Normal` for documentation purposes.
+    This class is an re-implementation of the `abcpy.continuousmodels.Normal` for documentation purposes.
     """
 
     def __init__(self, parameters, name='Gaussian'):
@@ -82,8 +82,8 @@ def infer_parameters():
                   188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509]
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu = Uniform([[150], [200]], )
-    sigma = Uniform([[5], [25]], )
+    mu = Uniform([[150], [200]], name="mu")
+    sigma = Uniform([[5], [25]], name="sigma")
     # define the model
     from abcpy.continuousmodels import Normal as Gaussian
     height = Gaussian([mu, sigma], name='height')
@@ -120,8 +120,8 @@ def infer_parameters():
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.parameters)
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -131,6 +131,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
@@ -139,15 +142,15 @@ def analyse_journal(journal):
 
 
 # this code is for testing purposes only and not relevant to run the example
-import unittest
-
-
-class ExampleExtendModelGaussianPython(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 177.02
-        self.assertLess(abs(test_result - expected_result), 2.)
+# import unittest
+#
+#
+# class ExampleExtendModelGaussianPython(unittest.TestCase):
+#     def test_example(self):
+#         journal = infer_parameters()
+#         test_result = journal.posterior_mean()[0]
+#         expected_result = 177.02
+#         self.assertLess(abs(test_result - expected_result), 2.)
 
 
 if __name__ == "__main__":
diff --git a/examples/extensions/perturbationkernels/multivariate_normal_kernel.py b/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
index 1eb970fc..8f862fe9 100644
--- a/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
+++ b/examples/extensions/perturbationkernels/multivariate_normal_kernel.py
@@ -11,7 +11,8 @@ def __init__(self, models):
         self.models = models
 
     def calculate_cov(self, accepted_parameters_manager, kernel_index):
-        """Calculates the covariance matrix relevant to this kernel.
+        """
+        Calculates the covariance matrix relevant to this kernel.
 
         Parameters
         ----------
@@ -25,16 +26,27 @@ def calculate_cov(self, accepted_parameters_manager, kernel_index):
         list
             The covariance matrix corresponding to this kernel.
         """
+        continuous_model = [[] for i in
+                            range(len(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index]))]
+        for i in range(len(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index])):
+            if isinstance(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][i][0],
+                          (np.float, np.float32, np.float64, np.int, np.int32, np.int64)):
+                continuous_model[i] = accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][i]
+            else:
+                continuous_model[i] = np.concatenate(
+                    accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][i])
+        continuous_model = np.array(continuous_model).astype(float)
+
         if accepted_parameters_manager.accepted_weights_bds is not None:
             weights = accepted_parameters_manager.accepted_weights_bds.value()
-            cov = np.cov(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index],
-                         aweights=weights.reshape(-1), rowvar=False)
+            cov = np.cov(continuous_model, aweights=weights.reshape(-1).astype(float), rowvar=False)
         else:
-            cov = np.cov(accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index], rowvar=False)
+            cov = np.cov(continuous_model, rowvar=False)
         return cov
 
     def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.random.RandomState()):
-        """Updates the parameter values contained in the accepted_paramters_manager using a multivariate normal distribution.
+        """
+        Updates the parameter values contained in the accepted_paramters_manager using a multivariate normal distribution.
 
         Parameters
         ----------
@@ -51,19 +63,38 @@ def update(self, accepted_parameters_manager, kernel_index, row_index, rng=np.ra
         -------
         np.ndarray
             The perturbed parameter values.
-
         """
-        # Get all current parameter values relevant for this model
+
+        # Get all current parameter values relevant for this model and the structure
         continuous_model_values = accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index]
 
-        # Perturb
-        continuous_model_values = np.array(continuous_model_values)
-        cov = accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]
-        perturbed_continuous_values = rng.multivariate_normal(correctly_ordered_parameters[row_index], cov)
+        if isinstance(continuous_model_values[row_index][0],
+                      (np.float, np.float32, np.float64, np.int, np.int32, np.int64)):
+            # Perturb
+            cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
+            continuous_model_values = np.array(continuous_model_values).astype(float)
+
+            # Perturbed values anc split according to the structure
+            perturbed_continuous_values = rng.multivariate_normal(continuous_model_values[row_index], cov)
+        else:
+            # print('Hello')
+            # Learn the structure
+            struct = [[] for i in range(len(continuous_model_values[row_index]))]
+            for i in range(len(continuous_model_values[row_index])):
+                struct[i] = continuous_model_values[row_index][i].shape[0]
+            struct = np.array(struct).cumsum()
+            continuous_model_values = np.concatenate(continuous_model_values[row_index])
+
+            # Perturb
+            cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
+            continuous_model_values = np.array(continuous_model_values).astype(float)
+
+            # Perturbed values anc split according to the structure
+            perturbed_continuous_values = np.split(rng.multivariate_normal(continuous_model_values, cov), struct)[:-1]
 
         return perturbed_continuous_values
 
-    def pdf(self, accepted_parameters_manager, kernel_index, row_index, x):
+    def pdf(self, accepted_parameters_manager, kernel_index, mean, x):
         """Calculates the pdf of the kernel.
         Commonly used to calculate weights.
 
@@ -81,11 +112,13 @@ def pdf(self, accepted_parameters_manager, kernel_index, row_index, x):
         -------
         float
             The pdf evaluated at point x.
-                """
-
-        # Gets the relevant accepted parameters from the manager in order to calculate the pdf
-        mean = accepted_parameters_manager.kernel_parameters_bds.value()[kernel_index][row_index]
-
-        cov = accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]
+        """
 
-        return multivariate_normal(mean, cov).pdf(x)
+        if isinstance(mean[0], (np.float, np.float32, np.float64, np.int, np.int32, np.int64)):
+            mean = np.array(mean).astype(float)
+            cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
+            return multivariate_normal(mean, cov, allow_singular=True).pdf(np.array(x).astype(float))
+        else:
+            mean = np.array(np.concatenate(mean)).astype(float)
+            cov = np.array(accepted_parameters_manager.accepted_cov_mats_bds.value()[kernel_index]).astype(float)
+            return multivariate_normal(mean, cov, allow_singular=True).pdf(np.concatenate(x))
diff --git a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
index 939fa261..5a307446 100644
--- a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
+++ b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
@@ -1,5 +1,12 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
+
+# we show here how to choose explicitly the perturbation kernel for the PMCABC algorithm
+
 
 def infer_parameters():
     # The data corresponding to model_1 defined below
@@ -70,34 +77,39 @@ def infer_parameters():
     from abcpy.backends import BackendDummy as Backend
     backend = Backend()
 
-    # Define kernels
+    # Define kernels: we use two different kernels for two sets of parameters
     from abcpy.perturbationkernel import MultivariateNormalKernel, MultivariateStudentTKernel
-    kernel_1 = MultivariateNormalKernel([school_budget, \
-                                         scholarship_without_additional_effects, grade_without_additional_effects])
+    kernel_1 = MultivariateNormalKernel(
+        [school_budget, scholarship_without_additional_effects, grade_without_additional_effects])
     kernel_2 = MultivariateStudentTKernel([class_size, no_teacher], df=3)
 
     # Join the defined kernels
     from abcpy.perturbationkernel import JointPerturbationKernel
     kernel = JointPerturbationKernel([kernel_1, kernel_2])
 
-    # Define sampling parameters
-    T, n_sample, n_samples_per_param = 3, 250, 10
-    eps_arr = np.array([.75])
+    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
+    # n_samples_per_param is the number of simulated datasets for each posterior sample.
+    T, n_sample, n_samples_per_param = 3, 50, 10
+    eps_arr = np.array([30])  # starting value of epsilon; the smaller, the slower the algorithm.
+    # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
+    # iteration from the observation
     epsilon_percentile = 10
 
     # Define sampler
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([final_grade, final_scholarship], [distance_calculator, distance_calculator], backend, kernel)
+    sampler = PMCABC([final_grade, final_scholarship],
+                     [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel)
 
     # Sample
-    journal = sampler.sample([y_obs_grades, y_obs_scholarship], T, eps_arr, n_sample, n_samples_per_param,
+    journal = sampler.sample([grades_obs, scholarship_obs], T, eps_arr, n_sample, n_samples_per_param,
                              epsilon_percentile)
+    return journal
 
 
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.get_stored_output_values())
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -107,6 +119,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
index ea60c36a..4c48920b 100644
--- a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
+++ b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
@@ -1,5 +1,9 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
 """An example showing how to implement a bayesian network in ABCpy. We consider here two hierarchical models which 
 depend on a common set of parameters (with prior distributions) and for which we get two sets of observations. Inference
 on the parameters can be performed jointly."""
@@ -80,9 +84,12 @@ def infer_parameters():
     kernel = DefaultKernel([school_budget, class_size, grade_without_additional_effects,
                             no_teacher, scholarship_without_additional_effects])
 
-    # Define sampling parameters
-    T, n_sample, n_samples_per_param = 3, 250, 10
-    eps_arr = np.array([.75])
+    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
+    # n_samples_per_param is the number of simulated datasets for each posterior sample.
+    T, n_sample, n_samples_per_param = 3, 50, 10
+    eps_arr = np.array([30])  # starting value of epsilon; the smaller, the slower the algorithm.
+    # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
+    # iteration from the observation
     epsilon_percentile = 10
 
     # Define sampler; note here how the two models are passed in a list, as well as the two corresponding distance
@@ -91,15 +98,16 @@ def infer_parameters():
     sampler = PMCABC([final_grade, final_scholarship],
                      [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel)
 
-    # Sample; again, here we pass the two observations in a list
+    # Sample; again, here we pass the two sets of observations in a list
     journal = sampler.sample([grades_obs, scholarship_obs],
                              T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
     return journal
 
+
 def analyse_journal(journal):
     # output parameters and weights
-    print(journal.get_stored_output_values())
-    print(journal.weights)
+    print(journal.get_parameters())
+    print(journal.get_weights())
 
     # do post analysis
     print(journal.posterior_mean())
@@ -109,6 +117,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
diff --git a/examples/modelselection/randomforest_modelselections.py b/examples/modelselection/randomforest_modelselections.py
index 152534cc..eb72eaeb 100644
--- a/examples/modelselection/randomforest_modelselections.py
+++ b/examples/modelselection/randomforest_modelselections.py
@@ -1,5 +1,7 @@
+import logging
 from abcpy.modelselections import RandomForest
 
+logging.basicConfig(level=logging.INFO)
 
 def infer_model():
     # define observation for true parameters mean=170, std=15
@@ -33,7 +35,7 @@ def infer_model():
     # Choose the correct model
     model = modelselection.select_model(y_obs, n_samples=100, n_samples_per_param=1)
 
-    # Compute the posterior probability of each of the models
+    # Compute the posterior probability of the chosen model
     model_prob = modelselection.posterior_probability(y_obs)
 
     return model, model_prob
diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
index 99983a91..b1ccbc8d 100644
--- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
+++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
@@ -1,5 +1,9 @@
+import logging
+
 import numpy as np
 
+logging.basicConfig(level=logging.INFO)
+
 
 def infer_parameters():
     # define backend
@@ -23,8 +27,8 @@ def infer_parameters():
 
     # define prior
     from abcpy.continuousmodels import Uniform
-    mu = Uniform([[150], [200]], )
-    sigma = Uniform([[5], [25]], )
+    mu = Uniform([[150], [200]], name="mu")
+    sigma = Uniform([[5], [25]], name="sigma")
 
     # define the model
     from abcpy.continuousmodels import Normal
@@ -64,9 +68,12 @@ def infer_parameters():
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1)
 
-    # sample from scheme
+    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
+    # n_samples_per_param is the number of simulated datasets for each posterior sample.
     T, n_sample, n_samples_per_param = 3, 10, 10
-    eps_arr = np.array([500])
+    eps_arr = np.array([500])  # starting value of epsilon; the smaller, the slower the algorithm.
+    # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
+    # iteration from the observation
     epsilon_percentile = 10
     journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
@@ -86,6 +93,9 @@ def analyse_journal(journal):
     # print configuration
     print(journal.configuration)
 
+    # plot posterior
+    journal.plot_posterior_distr(path_to_save="posterior.png")
+
     # save and load journal
     journal.save("experiments.jnl")
 
@@ -93,7 +103,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-# this code is for testing purposes only and not relevant to run the exampl
 if __name__ == "__main__":
     journal = infer_parameters()
     analyse_journal(journal)

From 07a7cd8e4b35aa9922f082fc5d183b8f15cce01e Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 15:05:47 +0100
Subject: [PATCH 049/106] Fix requirements for spark and add some info on that
 in README.md

---
 README.md                      | 16 ++++++++++++++++
 requirements/backend-spark.txt |  1 +
 2 files changed, 17 insertions(+)

diff --git a/README.md b/README.md
index c9c2e70c..9463800b 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,22 @@ Further, we provide a
 [collection of models](https://github.com/eth-cscs/abcpy-models) for which ABCpy
 has been applied successfully. This is a good place to look at more complicated inference setups.
 
+# Quick installation and requirements
+
+
+ABCpy can be installed from `pip`: 
+
+    pip install abcpy
+
+Check [here](https://abcpy.readthedocs.io/en/latest/installation.html) for more details.
+
+Basic requirements are listed in `requirements.txt`. Additional packages are required for additional features: 
+
+- `torch` is needed in order to use neural networks to learn summary statistics. It can be installed by running `pip install -r requirements/optional-requirements.txt`
+- In order to use MPI for parallelization, `mpi4py` and `cloudpickle` are required; install them by `pip install -r requirements/backend-mpi.txt`  
+- In order to use Apache Spark for parallelization, `findspark` and `pyspark` are required; install them by `pip install -r requirements/backend-spark.txt`  
+
+
 # Author 
 ABCpy was written by [Ritabrata Dutta, Warwick
 University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/)
diff --git a/requirements/backend-spark.txt b/requirements/backend-spark.txt
index 2e186911..be5503dd 100644
--- a/requirements/backend-spark.txt
+++ b/requirements/backend-spark.txt
@@ -1 +1,2 @@
 findspark
+pyspark
\ No newline at end of file

From cc90b4240ec6b032dc64983f5ba0968fdad738f2 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 16:11:47 +0100
Subject: [PATCH 050/106] Add some troubleshooting info in README.md

---
 README.md                   | 16 ++++++++++++++++
 doc/source/installation.rst | 38 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9463800b..4a29ba1e 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,22 @@ Basic requirements are listed in `requirements.txt`. Additional packages are req
 - In order to use MPI for parallelization, `mpi4py` and `cloudpickle` are required; install them by `pip install -r requirements/backend-mpi.txt`  
 - In order to use Apache Spark for parallelization, `findspark` and `pyspark` are required; install them by `pip install -r requirements/backend-spark.txt`  
 
+## Troubleshooting `mpi4py` installation
+
+`mpi4py` requires a working MPI implementation to be installed; check the [official docs]((https://mpi4py.readthedocs.io/en/stable/install.html)) for more info. On Ubuntu, that can be installed with:
+
+    sudo apt-get install libopenmpi-dev
+
+Even when that is present, running `pip install mpi4py` can sometimes lead to errors. In fact, as specified in the [official docs]((https://mpi4py.readthedocs.io/en/stable/install.html)), the `mpicc` compiler needs to be in the search path. If that is not the case, a workaround is: 
+
+    env MPICC=/path/to/mpicc pip install mpi4py
+
+In some cases, even the above may not be enough. A possibility is using `conda` (`conda install mpi4py`) which usually handles package dependencies better than `pip`. Alternatively, you can try by installing directly `mpi4py` from the package manager; in Ubuntu, you can do:
+
+    sudo apt install python3-mpi4py 
+
+which however does not work with virtual environments.
+
 
 # Author 
 ABCpy was written by [Ritabrata Dutta, Warwick
diff --git a/doc/source/installation.rst b/doc/source/installation.rst
index 97521a93..e0e62207 100644
--- a/doc/source/installation.rst
+++ b/doc/source/installation.rst
@@ -13,7 +13,7 @@ Simplest way to install
 ::
    pip3 install abcpy
 
-This clearly works also in a virtual environment.
+This also works in a virtual environment.
 
 
 Installation from Source
@@ -40,5 +40,41 @@ To create a package and install it, do
 
 Note that ABCpy requires Python3.
 
+Requirements
+~~~~~~~~~~~~
 
 
+Basic requirements are listed in ``requirements.txt`` in the repository (`click here
+<https://github.com/eth-cscs/abcpy/blob/master/requirements.txt>`_). Additional packages are required for additional features:
+
+- ``torch`` is needed in order to use neural networks to learn summary statistics. It can be installed by running: ::
+
+    pip install -r requirements/optional-requirements.txt
+- In order to use MPI for parallelization, ``mpi4py`` and ``cloudpickle`` are required; install them by: ::
+
+    pip install -r requirements/backend-mpi.txt
+- In order to use Apache Spark for parallelization, ``findspark`` and ``pyspark`` are required; install them by: ::
+
+    pip install -r requirements/backend-spark.txt
+
+
+
+Troubleshooting ``mpi4py`` installation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``mpi4py`` requires a working MPI implementation to be installed; check the `official docs
+<https://mpi4py.readthedocs.io/en/stable/install.html>`_ for more info. On Ubuntu, that can be installed with:
+::
+    sudo apt-get install libopenmpi-dev
+
+Even when that is present, running ``pip install mpi4py`` can sometimes lead to errors. In fact, as specified in the `official docs
+<https://mpi4py.readthedocs.io/en/stable/install.html>`_, the ``mpicc`` compiler needs to be in the search path. If that is not the case, a workaround is:
+::
+    env MPICC=/path/to/mpicc pip install mpi4py
+
+In some cases, even the above may not be enough. A possibility is using ``conda`` (``conda install mpi4py``) which usually handles package dependencies better than ``pip``. Alternatively, you can try by installing directly ``mpi4py`` from the package manager; in Ubuntu, you can do:
+::
+    sudo apt install python3-mpi4py
+
+which however does not work with virtual environments.
+

From 543927cce4ad5832235dd869b30bd59f5f8941c1 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 19:06:07 +0100
Subject: [PATCH 051/106] Add notebook for getting started tutorial

---
 examples/getting_started.ipynb | 610 +++++++++++++++++++++++++++++++++
 1 file changed, 610 insertions(+)
 create mode 100644 examples/getting_started.ipynb

diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb
new file mode 100644
index 00000000..c1260b9b
--- /dev/null
+++ b/examples/getting_started.ipynb
@@ -0,0 +1,610 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# First example of ABCpy inference scheme\n",
+    "\n",
+    "In this notebook we show how to use ABCpy to quantify parameter uncertainty of a probabilistic model given some observed\n",
+    "dataset.\n",
+    "\n",
+    "## Outline\n",
+    "\n",
+    "We consider a simple model of group of grown up humans. Specifically, we assume a gaussian distribution to be\n",
+    "an appropriate probabilistic model for these kind of observations. This gaussian distribution will have unknown mean and\n",
+    "standard deviation parameters; in Bayesian inference, these parameters are considered to be random variables, to which\n",
+    "a prior probability distribution is assigned.\n",
+    "\n",
+    "Then, we assume we have a set of measurements of height of some people, and we want to infer a probability distribution\n",
+    "over the parameters. We will perform inference using Approximate Bayesian Computation (ABC), which is a Bayesian\n",
+    "inference technique which only requires the ability to simulate from the model.\n",
+    "\n",
+    "In the following, we will walk through the steps required to do this in ABCpy. For further information, check also\n",
+    "[the documentation page]() where this and other examples are presented as well."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Probabilistic model\n",
+    "\n",
+    "In ABCpy, the probabilistic model is defined hierarchically; here, we first defined put uniform priors on the parameters,\n",
+    "which are in turn used to define the model for the height. Each element can be assigned an optional"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [],
+   "source": [
+    "# define priors\n",
+    "from abcpy.continuousmodels import Uniform, Normal as Gaussian\n",
+    "mu = Uniform([[150], [200]], name=\"mu\")\n",
+    "sigma = Uniform([[5], [25]], name=\"sigma\")\n",
+    "# define the model\n",
+    "height = Gaussian([mu, sigma], name='height')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Each model in ABCpy has to have a `forward_simulate` method, which generates simulations from the model with fixed\n",
+    "parameter values:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[array([183.32569845]), array([214.16368762]), array([176.23175713])]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate 3 observations from the model with mean 185 and standard deviation 20\n",
+    "x_sim = height.forward_simulate([185, 20], k=3)\n",
+    "print(x_sim)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "As you can see, the above returns a list of 3 simulations, which in this case are 1 dimensional arrays with one single\n",
+    "element."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Statistics computation\n",
+    "ABC algorithms rely on a measure of discrepancy between the observed dataset and the dataset which is simulated from\n",
+    "the model. Often, the discrepancy\n",
+    "measure is defined by computing a distance between relevant *summary statistics* extracted from the datasets. Here we\n",
+    "first define a way to extract *summary statistics* from the dataset:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "from abcpy.statistics import Identity\n",
+    "statistics_calculator = Identity(degree=2, cross=False)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "the above defines an `Identity` statistic, which only applies a polynomial expansion to the data up to the chosen degree\n",
+    " (2 here) and optionally adds cross product terms between all the terms in each observation. Let's see how this works:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3, 2)\n",
+      "[  214.16368762 45866.08509543]\n"
+     ]
+    }
+   ],
+   "source": [
+    "stat_sim = statistics_calculator.statistics(x_sim)\n",
+    "print(stat_sim.shape)\n",
+    "print(stat_sim[1])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The statistic calculator returns a numpy array in which `stat_sim[i]` is the set of statistics corresponding to the\n",
+    "i-th observation in `x_sim`, which in this case is composed of two elements (the first and second power of the simulated\n",
+    "data).\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Discrepany measure\n",
+    "\n",
+    "Next we define the discrepancy measure between the datasets, by defining a distance function (we choose here the\n",
+    "Euclidean one) between the extracted summary statistics."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [],
+   "source": [
+    "from abcpy.distances import Euclidean\n",
+    "distance_calculator = Euclidean(statistics_calculator)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Note that the `Distance` object takes as an argument a statistics_calculator; in fact, when calling the corresponding\n",
+    "`distance` method on two dataset, the statistics are computed automatically and the distance between them evaluated:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7055.339346417502\n"
+     ]
+    }
+   ],
+   "source": [
+    "# generate two observation:\n",
+    "x_1 = height.forward_simulate([185, 20], k=1)\n",
+    "x_2 = height.forward_simulate([170, 20], k=1)\n",
+    "\n",
+    "print(distance_calculator.distance(x_1, x_2))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Inference\n",
+    "\n",
+    "In order to perform inference, an inference algorithm is required. However, we also need to specify a\n",
+    "parallelization backend; here, we use the `BackendDummy` one, which does not parallelize and is useful for debug and\n",
+    "testing; however, ABCpy allows distribution of simulations from the model through MPI and Apache Spark\n",
+    "(see [here](https://abcpy.readthedocs.io/en/latest/parallelization.html))."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [],
+   "source": [
+    "from abcpy.backends import BackendDummy as Backend\n",
+    "backend = Backend()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Now, we define the inference algorithm. For simplicity, we use here the basic RejectionABC algorithm. Note that ABCpy implements several\n",
+    "more efficient algorithms, which are listed [here](https://abcpy.readthedocs.io/en/latest/getting_started.html#inference-schemes).\n",
+    "\n",
+    "To instantiate an inference algorithm, we need to pass to it the model, the distance calculator that will be used\n",
+    "during inference and the parallelization backed. We can also pass a seed for random numbers reproducibility:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [],
+   "source": [
+    "from abcpy.inferences import RejectionABC\n",
+    "sampler = RejectionABC([height], [distance_calculator], backend, seed=1)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Note that both the model and the distance calculator have to be passed in a list; this may seem superfluous, but the\n",
+    " reason is that in ABCpy it is possible to perform inference with models which describe different observations but\n",
+    " depend on a common set of parameters; see more details [here](https://abcpy.readthedocs.io/en/latest/getting_started.html#hierarchical-model)."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We now generate an observation from which inference is performed:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [],
+   "source": [
+    "height_obs = height.forward_simulate([170, 15], k=50)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Finally, we perform sampling by calling the `sample` method in the sampler. We require to obtain 250 posterior samples\n",
+    "(`n_sample` parameter); during the inference procedure, we generate 10 simulations for each parameter value with which\n",
+    "to compute the distance from the observation. RejectionABC accepts all parameter values (generated from priors) for\n",
+    "which the corresponding distance (between observation and simulated dataset) is smaller than `epsilon`:"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [],
+   "source": [
+    "# this may take a while according to the setup\n",
+    "n_sample, n_samples_per_param = 250, 10\n",
+    "epsilon = 5000\n",
+    "journal = sampler.sample([height_obs], n_sample, n_samples_per_param, epsilon)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Note that here again the observation is passed in a list; if we were performing inference on multiple models at once,\n",
+    "the list would contain an observation for each model.\n",
+    "\n",
+    "## Results postprocessing\n",
+    "Now, the inference results are stored in the `journal` file. We can analyse that in several ways; for instance, we can\n",
+    "get the parameter posterior samples:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of posterior samples: 250\n",
+      "10 posterior samples for mu:\n",
+      "[[array([179.7435489])], [array([172.57267485])], [array([170.7175767])], [array([178.79118242])], [array([181.19496513])], [array([163.19262033])], [array([178.25523055])], [array([170.29002602])], [array([174.08226834])], [array([176.18883946])]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "params = journal.get_parameters()  # this returns a dict whose keys are parameter names\n",
+    "print(\"Number of posterior samples: {}\".format(len(params['mu'])))\n",
+    "print(\"10 posterior samples for mu:\")\n",
+    "print(params['mu'][0:10])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "We can also get the posterior mean and covariance matrix:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Posterior mean {'mu': 169.90286133850347, 'sigma': 9.566450202710163}\n",
+      "Covariance matrix:\n",
+      "(array([[34.99754605,  0.40426959],\n",
+      "       [ 0.40426959, 12.87931016]]), dict_keys(['mu', 'sigma']))\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Posterior mean\", journal.posterior_mean())\n",
+    "print(\"Covariance matrix:\")\n",
+    "print(journal.posterior_cov())"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "The journal also stores the configuration of the sampler with which it was generated:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'n_samples': 250, 'n_samples_per_param': 10, 'epsilon': 5000}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(journal.configuration)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Finally, we have a function to plot a kernel density estimate of the obtained posterior; this function has many\n",
+    "arguments, allowing to get custom plots:"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(<Figure size 576x576 with 4 Axes>,\n array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7fe176e14610>,\n         <matplotlib.axes._subplots.AxesSubplot object at 0x7fe174dbd190>],\n        [<matplotlib.axes._subplots.AxesSubplot object at 0x7fe174d6b5b0>,\n         <matplotlib.axes._subplots.AxesSubplot object at 0x7fe174d17a00>]],\n       dtype=object))"
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 576x576 with 4 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "journal.plot_posterior_distr(true_parameter_values=[170,15])"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Also, we can save the journal to disk and reload it later:\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "outputs": [],
+   "source": [
+    "from abcpy.output import Journal\n",
+    "journal.save(\"experiments.jnl\")\n",
+    "new_journal = Journal.fromFile('experiments.jnl')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file

From 67de4682a4f1d36ca49d3271abaad16c9f5e8294 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 21:28:20 +0100
Subject: [PATCH 052/106] Fix test for approx lhd

---
 tests/approx_lhd_tests.py | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/tests/approx_lhd_tests.py b/tests/approx_lhd_tests.py
index 3e11f336..9f005e74 100644
--- a/tests/approx_lhd_tests.py
+++ b/tests/approx_lhd_tests.py
@@ -20,6 +20,13 @@ def setUp(self):
                                             seed=1)
         self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10,
                                           max_iter=100000, seed=1)
+
+        self.y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))
+        self.y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1,
+                                                                     rng=np.random.RandomState(1))
+        self.y_obs_double = self.model.forward_simulate(self.model.get_input_values(), 2, rng=np.random.RandomState(1))
+        self.y_obs_bivariate_double = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 2,
+                                                                            rng=np.random.RandomState(1))
         # create fake simulated data
         self.mu._fixed_values = [1.1]
         self.sigma._fixed_values = [1.0]
@@ -33,8 +40,7 @@ def test_likelihood(self):
         self.assertRaises(TypeError, self.likfun.likelihood, [2, 4], 3.4)
 
         # create observed data
-        y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1))
-        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
+        comp_likelihood = self.likfun.likelihood(self.y_obs, self.y_sim)
         expected_likelihood = 9.77317308598673e-08
         # This checks whether it computes a correct value and dimension is right. Not correct as it does not check the
         # absolute value:
@@ -42,25 +48,20 @@ def test_likelihood(self):
         self.assertAlmostEqual(comp_likelihood, expected_likelihood)
 
         # check if it returns the correct error when n_samples does not match:
-        self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.likelihood, y_obs, self.y_sim)
+        self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.likelihood, self.y_obs, self.y_sim)
 
         # try now with the bivariate uniform model:
-        y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1,
-                                                                rng=np.random.RandomState(1))
-        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, self.y_sim_bivariate)
+        comp_likelihood_biv = self.likfun_bivariate.likelihood(self.y_obs_bivariate, self.y_sim_bivariate)
         expected_likelihood_biv = 0.999999999999999
         self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
 
     def test_likelihood_multiple_observations(self):
-        y_obs = self.model.forward_simulate(self.model.get_input_values(), 2, rng=np.random.RandomState(1))
-        comp_likelihood = self.likfun.likelihood(y_obs, self.y_sim)
-        expected_likelihood = 6.547737649959798
+        comp_likelihood = self.likfun.likelihood(self.y_obs, self.y_sim)
+        expected_likelihood = 9.77317308598673e-08
         self.assertAlmostEqual(comp_likelihood, expected_likelihood)
 
-        y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 2,
-                                                                rng=np.random.RandomState(1))
         expected_likelihood_biv = 0.9999999999999979
-        comp_likelihood_biv = self.likfun_bivariate.likelihood(y_obs_bivariate, self.y_sim_bivariate)
+        comp_likelihood_biv = self.likfun_bivariate.likelihood(self.y_obs_bivariate, self.y_sim_bivariate)
         self.assertAlmostEqual(comp_likelihood_biv, expected_likelihood_biv)
 
 

From 2bfc0af8d0abca156cf246faeac85b355522326d Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 21:43:11 +0100
Subject: [PATCH 053/106] Remove packages needed for MPI parallelization from
 requirements.txt

---
 requirements.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index d09c5a54..f028e251 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,7 +5,5 @@ glmnet>=2.2.1
 sphinx
 sphinx_rtd_theme 
 coverage
-mpi4py
-cloudpickle
 matplotlib
 tqdm
\ No newline at end of file

From f41c6972462d8065472e5f7f6d208147a04c3489 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 21:50:24 +0100
Subject: [PATCH 054/106] Fix error in setup.py for binder

---
 setup.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/setup.py b/setup.py
index 1b4ad955..4dac8d96 100644
--- a/setup.py
+++ b/setup.py
@@ -7,10 +7,10 @@
     from pip._internal.req import parse_requirements
 except ImportError: # for pip <= 9.0.3
     from pip.req import parse_requirements
-    
+
 try: # for pip >= 19.3
     from pip._internal.network.session import PipSession
-except ImportError: 
+except ImportError:
     try: # for pip < 19.3 and >=10
         from pip._internal.download import PipSession
     except ImportError: # for pip <= 9.0.3
@@ -19,12 +19,16 @@
 here = path.abspath(path.dirname(__file__))
 
 install_reqs_raw = parse_requirements('requirements.txt', session=PipSession())
-install_reqs = [str(ir.req) for ir in install_reqs_raw]
+
+try:
+    install_reqs = [str(ir.req) for ir in install_reqs_raw]
+except AttributeError:
+    requirements = [str(ir.requirement) for ir in install_reqs_raw]
 
 with open(path.join(here, 'VERSION')) as f:
     version = f.readline().strip()
     file_tgz = 'v' + version + '.tar.gz'
-    
+
 setup(
     name='abcpy',
 
@@ -39,7 +43,7 @@
     # The project's main homepage.
     url='https://github.com/eth-cscs/abcpy',
     download_url = 'https://github.com/eth-cscs/abcpy/archive/' + file_tgz,
-    
+
     # Author details
     author='The abcpy authors',
     author_email='',

From da2c1302b0dc8576123dec7e85aea7803a7d8e8c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 21:55:26 +0100
Subject: [PATCH 055/106] Fix error in setup.py for binder

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 4dac8d96..b6231410 100644
--- a/setup.py
+++ b/setup.py
@@ -23,7 +23,7 @@
 try:
     install_reqs = [str(ir.req) for ir in install_reqs_raw]
 except AttributeError:
-    requirements = [str(ir.requirement) for ir in install_reqs_raw]
+    install_reqs = [str(ir.requirement) for ir in install_reqs_raw]
 
 with open(path.join(here, 'VERSION')) as f:
     version = f.readline().strip()

From 0742038f2e994822d27a2f8b4a1b732186f61f39 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 28 Oct 2020 22:02:02 +0100
Subject: [PATCH 056/106] Add binder link

---
 README.md                      | 2 +-
 examples/getting_started.ipynb | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4a29ba1e..142d4363 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy)
+# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples%2Fgetting_started.ipynb)
 
 ABCpy is a scientific library written in Python for Bayesian uncertainty quantification in
 absence of likelihood function, which parallelizes existing approximate Bayesian computation (ABC) 
diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb
index c1260b9b..61374da3 100644
--- a/examples/getting_started.ipynb
+++ b/examples/getting_started.ipynb
@@ -3,6 +3,8 @@
   {
    "cell_type": "markdown",
    "source": [
+    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples%2Fgetting_started.ipynb)\n",
+    "\n",
     "# First example of ABCpy inference scheme\n",
     "\n",
     "In this notebook we show how to use ABCpy to quantify parameter uncertainty of a probabilistic model given some observed\n",

From 1813935f165ef843eba8db53f6fec8425a6b91dd Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 29 Oct 2020 17:27:20 +0100
Subject: [PATCH 057/106] Some cleanup in Examples

---
 .../approx_lhd/pmc_hierarchical_models.py     |  1 -
 .../backends/apache_spark/pmcabc_gaussian.py  |  1 -
 examples/backends/dummy/pmcabc_gaussian.py    |  1 -
 examples/backends/mpi/pmcabc_gaussian.py      |  1 -
 .../extensions/models/gaussian_R/graph_ABC.py | 28 -------------------
 .../pmcabc-gaussian_model_simple.py           |  1 -
 .../pmcabc-gaussian_model_simple.py           |  1 -
 .../pmcabc-gaussian_model_simple.py           |  1 -
 .../pmcabc-gaussian_model_simple.py           |  1 -
 .../pmcabc_perturbation_kernels.py            |  1 -
 ...mcabc_inference_on_multiple_sets_of_obs.py |  1 -
 .../randomforest_modelselections.py           |  3 ++
 .../pmcabc_gaussian_statistics_learning.py    |  1 -
 13 files changed, 3 insertions(+), 39 deletions(-)
 delete mode 100644 examples/extensions/models/gaussian_R/graph_ABC.py

diff --git a/examples/approx_lhd/pmc_hierarchical_models.py b/examples/approx_lhd/pmc_hierarchical_models.py
index 477643ca..dcf5ef14 100644
--- a/examples/approx_lhd/pmc_hierarchical_models.py
+++ b/examples/approx_lhd/pmc_hierarchical_models.py
@@ -100,7 +100,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/backends/apache_spark/pmcabc_gaussian.py b/examples/backends/apache_spark/pmcabc_gaussian.py
index 1c377be9..c108bacf 100644
--- a/examples/backends/apache_spark/pmcabc_gaussian.py
+++ b/examples/backends/apache_spark/pmcabc_gaussian.py
@@ -67,7 +67,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/backends/dummy/pmcabc_gaussian.py b/examples/backends/dummy/pmcabc_gaussian.py
index 5d82b96f..e7889ea8 100644
--- a/examples/backends/dummy/pmcabc_gaussian.py
+++ b/examples/backends/dummy/pmcabc_gaussian.py
@@ -67,7 +67,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/backends/mpi/pmcabc_gaussian.py b/examples/backends/mpi/pmcabc_gaussian.py
index 9afa300e..2145136f 100644
--- a/examples/backends/mpi/pmcabc_gaussian.py
+++ b/examples/backends/mpi/pmcabc_gaussian.py
@@ -68,7 +68,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/extensions/models/gaussian_R/graph_ABC.py b/examples/extensions/models/gaussian_R/graph_ABC.py
deleted file mode 100644
index 15bcae9b..00000000
--- a/examples/extensions/models/gaussian_R/graph_ABC.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.stats import gaussian_kde
-
-
-def plot(samples, path=None, true_value=5, title='ABC posterior'):
-    Bayes_estimate = np.mean(samples, axis=0)
-    theta = true_value
-    xmin, xmax = max(samples[:, 0]), min(samples[:, 0])
-    positions = np.linspace(xmin, xmax, samples.shape[0])
-    gaussian_kernel = gaussian_kde(samples[:, 0].reshape(samples.shape[0], ))
-    values = gaussian_kernel(positions)
-    plt.figure()
-    plt.plot(positions, gaussian_kernel(positions))
-    plt.plot([theta, theta], [min(values), max(values) + .1 * (max(values) - min(values))])
-    plt.plot([Bayes_estimate, Bayes_estimate], [min(values), max(values) + .1 * (max(values) - min(values))])
-    plt.ylim([min(values), max(values) + .1 * (max(values) - min(values))])
-    plt.xlabel(r'$\theta$')
-    plt.ylabel('density')
-    # plt.xlim([0,1])
-    plt.rc('axes', labelsize=15)
-    plt.legend(loc='best', frameon=False, numpoints=1)
-    font = {'size': 15}
-    plt.rc('font', **font)
-    plt.title(title)
-    if path is not None:
-        plt.savefig(path)
-    return plt
diff --git a/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
index f40b9105..b5b7d12e 100644
--- a/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
@@ -130,7 +130,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
index 20a9dccd..8e62dc54 100644
--- a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
@@ -121,7 +121,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
index 8fcc4aef..05cb58ed 100644
--- a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
@@ -124,7 +124,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
index 7c2b82a2..23815c2f 100644
--- a/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
@@ -126,7 +126,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
index 5a307446..d6cc9e79 100644
--- a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
+++ b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
@@ -114,7 +114,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
index 4c48920b..54920d21 100644
--- a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
+++ b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
@@ -112,7 +112,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)
diff --git a/examples/modelselection/randomforest_modelselections.py b/examples/modelselection/randomforest_modelselections.py
index eb72eaeb..67940da2 100644
--- a/examples/modelselection/randomforest_modelselections.py
+++ b/examples/modelselection/randomforest_modelselections.py
@@ -1,8 +1,10 @@
 import logging
+
 from abcpy.modelselections import RandomForest
 
 logging.basicConfig(level=logging.INFO)
 
+
 def infer_model():
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176]
@@ -40,6 +42,7 @@ def infer_model():
 
     return model, model_prob
 
+
 if __name__ == "__main__":
     model, model_prob = infer_model()
     print(f"The correct model is {model.name} with estimated posterior probability {model_prob[0]}.")
diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
index b1ccbc8d..947d2802 100644
--- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
+++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
@@ -88,7 +88,6 @@ def analyse_journal(journal):
     # do post analysis
     print(journal.posterior_mean())
     print(journal.posterior_cov())
-    print(journal.posterior_histogram())
 
     # print configuration
     print(journal.configuration)

From 78b199a93414cc9d3e9394cb07ed969cad17eb06 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 29 Oct 2020 19:01:16 +0100
Subject: [PATCH 058/106] Add coverage for backends tests too

---
 Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 710ddf5a..009e2e03 100644
--- a/Makefile
+++ b/Makefile
@@ -47,9 +47,10 @@ coveragetest:
 	command -v coverage >/dev/null 2>&1 || { echo >&2 "Python package 'coverage' has to been installed. Please, run 'pip3 install coverage'."; exit;}
 	@- $(foreach TEST, $(UNITTESTS), \
 		echo === Testing code coverage: $(TEST); \
-		python3 -m unittest $(TEST); \
 		coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest $(TEST); \
 	)
+	mpirun -np 2 coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest tests/backend_tests_mpi.py
+	mpirun -np 3 python3 -m unittest discover -s tests -v -p "backend_tests_mpi_model_mpi.py" || (echo "Error in MPI unit tests."; exit 1)
 	coverage html -d build/testcoverage
 	coverage report
 	@echo

From 5b5662dfd92f04992e85abd210f7f87ce9bf5ee7 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 10:44:32 +0100
Subject: [PATCH 059/106] Fix checks for distances and approx_lhd if the new
 observation is same as the previous one.

---
 abcpy/approx_lhd.py |  9 +++++++--
 abcpy/distances.py  | 19 ++++++++++++++-----
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/abcpy/approx_lhd.py b/abcpy/approx_lhd.py
index 921778b0..b69f8bc1 100644
--- a/abcpy/approx_lhd.py
+++ b/abcpy/approx_lhd.py
@@ -78,7 +78,9 @@ def likelihood(self, y_obs, y_sim):
 
         # Check whether y_obs is same as the stored dataset.
         if self.data_set is not None:
-            if len(np.array(y_obs[0]).reshape(-1, )) == 1:
+            if len(y_obs) != len(self.data_set):
+                self.dataSame = False
+            elif len(np.array(y_obs[0]).reshape(-1, )) == 1:
                 self.dataSame = self.data_set == y_obs
             else:  # otherwise it fails when y_obs[0] is array
                 self.dataSame = all(
@@ -175,7 +177,10 @@ def likelihood(self, y_obs, y_sim):
 
         # Check whether y_obs is same as the stored dataset.
         if self.data_set is not None:
-            if len(np.array(y_obs[0]).reshape(-1, )) == 1:
+            # check that the the observations have the same length; if not, they can't be the same:
+            if len(y_obs) != len(self.data_set):
+                self.dataSame = False
+            elif len(np.array(y_obs[0]).reshape(-1, )) == 1:
                 self.dataSame = self.data_set == y_obs
             else:  # otherwise it fails when y_obs[0] is array
                 self.dataSame = all(
diff --git a/abcpy/distances.py b/abcpy/distances.py
index c1532420..b99a14d9 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -134,7 +134,10 @@ def distance(self, d1, d2):
 
         # Check whether d1 is same as self.data_set
         if self.data_set is not None:
-            if len(np.array(d1[0]).reshape(-1,)) == 1:
+            # check that the the observations have the same length; if not, they can't be the same:
+            if len(d1) != len(self.data_set):
+                self.dataSame = False
+            elif len(np.array(d1[0]).reshape(-1, )) == 1:
                 self.dataSame = self.data_set == d1
             else:
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
@@ -204,8 +207,11 @@ def distance(self, d1, d2):
 
         # Check whether d1 is same as self.data_set
         if self.data_set is not None:
-            if len(np.array(d1[0]).reshape(-1,)) == 1:
-                self.data_set == d1
+            # check that the the observations have the same length; if not, they can't be the same:
+            if len(d1) != len(self.data_set):
+                self.dataSame = False
+            elif len(np.array(d1[0]).reshape(-1, )) == 1:
+                self.dataSame = self.data_set == d1
             else:
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 
@@ -269,8 +275,11 @@ def distance(self, d1, d2):
 
         # Check whether d1 is same as self.data_set
         if self.data_set is not None:
-            if len(np.array(d1[0]).reshape(-1,)) == 1:
-                self.data_set == d1
+            # check that the the observations have the same length; if not, they can't be the same:
+            if len(d1) != len(self.data_set):
+                self.dataSame = False
+            elif len(np.array(d1[0]).reshape(-1, )) == 1:
+                self.dataSame = self.data_set == d1
             else:
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 

From e9fc6517a1186daa7fd2b4832baa05b92feb1acb Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 10:46:44 +0100
Subject: [PATCH 060/106] Some style fixes

---
 abcpy/distances.py  | 61 ++++++++++++++++++++-------------------------
 abcpy/inferences.py |  2 +-
 2 files changed, 28 insertions(+), 35 deletions(-)

diff --git a/abcpy/distances.py b/abcpy/distances.py
index b99a14d9..9457e01f 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -5,9 +5,9 @@
 from sklearn import linear_model
 
 
-class Distance(metaclass = ABCMeta):
+class Distance(metaclass=ABCMeta):
     """This abstract base class defines how the distance between the observed and
-    simulated data should be implemented.    
+    simulated data should be implemented.
     """
 
     @abstractmethod
@@ -18,13 +18,12 @@ def __init__(self, statistics_calc):
 
         Parameters
         ----------
-        statistics_calc : abcpy.stasistics.Statistics 
+        statistics_calc : abcpy.stasistics.Statistics
             Statistics extractor object that conforms to the Statistics class.
         """
 
         raise NotImplementedError
 
-
     @abstractmethod
     def distance(d1, d2):
         """To be overwritten by any sub-class: should calculate the distance between two
@@ -35,24 +34,24 @@ def distance(d1, d2):
         The data sets d1 and d2 are array-like structures that contain n1 and n2 data
         points each.  An implementation of the distance function should work along
         the following steps:
-        
+
         1. Transform both input sets dX = [ dX1, dX2, ..., dXn ] to sX = [sX1, sX2,
         ..., sXn] using the statistics object. See _calculate_summary_stat method.
-        
+
         2. Calculate the mutual desired distance, here denoted by -, between the
         statistics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
-        
+
         Important: any sub-class must not calculate the distance between data sets
         d1 and d2 directly. This is the reason why any sub-class must be
         initialized with a statistics object.
-        
+
         Parameters
         ----------
         d1: Python list
             Contains n1 data points.
         d2: Python list
             Contains n2 data points.
-        
+
         Returns
         -------
         numpy.ndarray
@@ -61,12 +60,11 @@ def distance(d1, d2):
 
         raise NotImplementedError
 
-
     @abstractmethod
     def dist_max(self):
         """To be overwritten by sub-class: should return maximum possible value of the
         desired distance function.
- 
+
         Examples
         --------
         If the desired distance maps to :math:`\mathbb{R}`, this method should return numpy.inf.
@@ -79,8 +77,7 @@ def dist_max(self):
 
         raise NotImplementedError
 
-
-    def _calculate_summary_stat(self,d1,d2):
+    def _calculate_summary_stat(self, d1, d2):
         """Helper function that extracts the summary statistics s1 and s2 from d1 and
         d2 using the statistics object stored in self.statistics_calc.
 
@@ -99,7 +96,7 @@ def _calculate_summary_stat(self,d1,d2):
         """
         s1 = self.statistics_calc.statistics(d1)
         s2 = self.statistics_calc.statistics(d2)
-        return (s1,s2)
+        return (s1, s2)
 
 
 class Euclidean(Distance):
@@ -143,43 +140,40 @@ def distance(self, d1, d2):
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 
         # Extract summary statistics from the dataset
-        if(self.s1 is None or self.dataSame is False):
+        if self.s1 is None or self.dataSame is False:
             self.s1 = self.statistics_calc.statistics(d1)
             self.data_set = d1
 
         s2 = self.statistics_calc.statistics(d2)
 
         # compute distance between the statistics
-        dist = np.zeros(shape=(self.s1.shape[0],s2.shape[0]))
+        dist = np.zeros(shape=(self.s1.shape[0], s2.shape[0]))
         for ind1 in range(0, self.s1.shape[0]):
             for ind2 in range(0, s2.shape[0]):
-                dist[ind1,ind2] = np.sqrt(np.sum(pow(self.s1[ind1,:]-s2[ind2,:],2)))
+                dist[ind1, ind2] = np.sqrt(np.sum(pow(self.s1[ind1, :] - s2[ind2, :], 2)))
 
         return dist.mean()
 
-
     def dist_max(self):
         return np.inf
 
 
-
-
 class PenLogReg(Distance):
     """
     This class implements a distance mesure based on the classification accuracy.
 
-    The classification accuracy is calculated between two dataset d1 and d2 using 
-    lasso penalized logistics regression and return it as a distance. The lasso 
+    The classification accuracy is calculated between two dataset d1 and d2 using
+    lasso penalized logistics regression and return it as a distance. The lasso
     penalized logistic regression is done using glmnet package of Friedman et. al.
-    [2]. While computing the distance, the algorithm automatically chooses 
+    [2]. While computing the distance, the algorithm automatically chooses
     the most relevant summary statistics as explained in Gutmann et. al. [1].
     The maximum value of the distance is 1.0.
-       
+
     [1] Gutmann, M. U., Dutta, R., Kaski, S., & Corander, J. (2018). Likelihood-free inference via classification.
     Statistics and Computing, 28(2), 411-425.
-    
-    [2] Friedman, J., Hastie, T., and Tibshirani, R. (2010). Regularization 
-    paths for generalized linear models via coordinate descent. Journal of Statistical 
+
+    [2] Friedman, J., Hastie, T., and Tibshirani, R. (2010). Regularization
+    paths for generalized linear models via coordinate descent. Journal of Statistical
     Software, 33(1), 1–22.
     """
 
@@ -216,7 +210,7 @@ def distance(self, d1, d2):
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 
         # Extract summary statistics from the dataset
-        if(self.s1 is None or self.dataSame is False):
+        if self.s1 is None or self.dataSame is False:
             self.s1 = self.statistics_calc.statistics(d1)
             self.data_set = d1
         s2 = self.statistics_calc.statistics(d2)
@@ -233,17 +227,17 @@ def distance(self, d1, d2):
         groups += groups  # duplicate it as groups need to be defined for both datasets
         m = LogitNet(alpha=1, n_splits=self.n_folds)  # note we are not using random seed here!
         m = m.fit(training_set_features, training_set_labels, groups=groups)
-        distance = 2.0 * (m.cv_mean_score_[np.where(m.lambda_path_== m.lambda_max_)[0][0]] - 0.5)
-    
+        distance = 2.0 * (m.cv_mean_score_[np.where(m.lambda_path_ == m.lambda_max_)[0][0]] - 0.5)
+
         return distance
 
     def dist_max(self):
         return 1.0
-    
+
 
 class LogReg(Distance):
     """This class implements a distance measure based on the classification
-    accuracy [1]. The classification accuracy is calculated between two dataset d1 and d2 using 
+    accuracy [1]. The classification accuracy is calculated between two dataset d1 and d2 using
     logistics regression and return it as a distance. The maximum value of the distance is 1.0.
 
     [1] Gutmann, M. U., Dutta, R., Kaski, S., & Corander, J. (2018). Likelihood-free inference via classification.
@@ -267,7 +261,6 @@ def distance(self, d1, d2):
             A list, containing a list describing the data set
         """
 
-
         if not isinstance(d1, list):
             raise TypeError('Data is not of allowed types')
         if not isinstance(d2, list):
@@ -284,7 +277,7 @@ def distance(self, d1, d2):
                 self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
 
         # Extract summary statistics from the dataset
-        if(self.s1 is None or self.dataSame is False):
+        if self.s1 is None or self.dataSame is False:
             self.s1 = self.statistics_calc.statistics(d1)
             self.data_set = d1
         s2 = self.statistics_calc.statistics(d2)
diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index ecf6b9c7..ee8f1c87 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -449,7 +449,7 @@ def sample(self, observations, steps, epsilon_init, n_samples=10000, n_samples_p
 
             # 1: calculate resample parameters
             # print("INFO: Resampling parameters")
-            self.logger.info("Resamping parameters")
+            self.logger.info("Resampling parameters")
 
             params_and_dists_and_counter_pds = self.backend.map(self._resample_parameter, rng_pds)
             params_and_dists_and_counter = self.backend.collect(params_and_dists_and_counter_pds)

From 32904c576b7f7e4a7e55b4fac466007b7b90cc35 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 10:48:43 +0100
Subject: [PATCH 061/106] Add check in PenLogReg distance whether the two
 datasets have same number of elements (otherwise what we have is not a proper
 distance)

---
 abcpy/distances.py       | 14 ++++++++++----
 tests/distances_tests.py | 19 ++++++++++++-------
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/abcpy/distances.py b/abcpy/distances.py
index 9457e01f..67a4afe1 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -213,17 +213,23 @@ def distance(self, d1, d2):
         if self.s1 is None or self.dataSame is False:
             self.s1 = self.statistics_calc.statistics(d1)
             self.data_set = d1
+            self.n_simulate = self.s1.shape[0]
         s2 = self.statistics_calc.statistics(d2)
 
-        # compute distnace between the statistics 
+        if not s2.shape[0] == self.n_simulate:
+            raise RuntimeError("The number of simulations in the two data sets should be the same in order for "
+                               "the classification accuracy implemented in PenLogReg to be a proper distance. Please "
+                               "check that `n_samples` in the `sample()` method for the sampler is equal to "
+                               "the number of datasets in the observations.")
+
+        # compute distance between the statistics
         training_set_features = np.concatenate((self.s1, s2), axis=0)
         label_s1 = np.zeros(shape=(len(self.s1), 1))
         label_s2 = np.ones(shape=(len(s2), 1))
         training_set_labels = np.concatenate((label_s1, label_s2), axis=0).ravel()
 
-        n_simulate = self.s1.shape[0]
-        groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(n_simulate / self.n_folds)))
-        groups = groups[:n_simulate].tolist()
+        groups = np.repeat(np.arange(self.n_folds), np.int(np.ceil(self.n_simulate / self.n_folds)))
+        groups = groups[:self.n_simulate].tolist()
         groups += groups  # duplicate it as groups need to be defined for both datasets
         m = LogitNet(alpha=1, n_splits=self.n_folds)  # note we are not using random seed here!
         m = m.fit(training_set_features, training_set_labels, groups=groups)
diff --git a/tests/distances_tests.py b/tests/distances_tests.py
index c427f25e..0ae2178a 100644
--- a/tests/distances_tests.py
+++ b/tests/distances_tests.py
@@ -34,13 +34,14 @@ def test_dist_max(self):
 
 class PenLogRegTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc = Identity(degree=1, cross=0)
+        self.stat_calc = Identity(degree=1, cross=False)
         self.distancefunc = PenLogReg(self.stat_calc)
+        self.rng = np.random.RandomState(1)
 
     def test_distance(self):
-        d1 = 0.5 * np.random.randn(100, 2) - 10
-        d2 = 0.5 * np.random.randn(100, 2) + 10
-        d3 = 0.5 * np.random.randn(95, 2) + 10
+        d1 = 0.5 * self.rng.randn(100, 2) - 10
+        d2 = 0.5 * self.rng.randn(100, 2) + 10
+        d3 = 0.5 * self.rng.randn(95, 2) + 10
 
         d1 = d1.tolist()
         d2 = d2.tolist()
@@ -59,18 +60,22 @@ def test_distance(self):
         # in cross validation (10)
         self.assertEqual(self.distancefunc.distance(d3, d3), 0.0)
 
+        # check if it returns the correct error when the number of datasets:
+        self.assertRaises(RuntimeError, self.distancefunc.distance, d1, d3)
+
     def test_dist_max(self):
         self.assertTrue(self.distancefunc.dist_max() == 1.0)
 
 
 class LogRegTests(unittest.TestCase):
     def setUp(self):
-        self.stat_calc = Identity(degree=1, cross=0)
+        self.stat_calc = Identity(degree=2, cross=False)
         self.distancefunc = LogReg(self.stat_calc)
+        self.rng = np.random.RandomState(1)
 
     def test_distance(self):
-        d1 = 0.5 * np.random.randn(100, 2) - 10
-        d2 = 0.5 * np.random.randn(100, 2) + 10
+        d1 = 0.5 * self.rng.randn(100, 2) - 10
+        d2 = 0.5 * self.rng.randn(100, 2) + 10
 
         d1 = d1.tolist()
         d2 = d2.tolist()

From b62ae36ab4ba21d896af7bdca5c1155d6209e7bf Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 10:53:27 +0100
Subject: [PATCH 062/106] Add optional random seeding in LogReg distance

---
 abcpy/distances.py       | 6 ++++--
 tests/distances_tests.py | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/abcpy/distances.py b/abcpy/distances.py
index 67a4afe1..dad729c6 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -250,13 +250,14 @@ class LogReg(Distance):
     Statistics and Computing, 28(2), 411-425.
     """
 
-    def __init__(self, statistics):
+    def __init__(self, statistics, seed=None):
         self.statistics_calc = statistics
 
         # Since the observations do always stay the same, we can save the summary statistics of them and not recalculate it each time
         self.s1 = None
         self.data_set = None
         self.dataSame = False
+        self.seed = seed  # optional seed for the random split in the LogisticRegression classifier.
 
     def distance(self, d1, d2):
         """Calculates the distance between two datasets.
@@ -295,7 +296,8 @@ def distance(self, d1, d2):
         training_set_labels = np.concatenate((label_s1, label_s2), axis=0).ravel()
 
         reg_inv = 1e5
-        log_reg_model = linear_model.LogisticRegression(C=reg_inv, penalty='l1', max_iter=1000, solver='liblinear')
+        log_reg_model = linear_model.LogisticRegression(C=reg_inv, penalty='l1', max_iter=1000, solver='liblinear',
+                                                        random_state=self.seed)
         log_reg_model.fit(training_set_features, training_set_labels)
         score = log_reg_model.score(training_set_features, training_set_labels)
         distance = 2.0 * (score - 0.5)
diff --git a/tests/distances_tests.py b/tests/distances_tests.py
index 0ae2178a..8121f568 100644
--- a/tests/distances_tests.py
+++ b/tests/distances_tests.py
@@ -70,7 +70,7 @@ def test_dist_max(self):
 class LogRegTests(unittest.TestCase):
     def setUp(self):
         self.stat_calc = Identity(degree=2, cross=False)
-        self.distancefunc = LogReg(self.stat_calc)
+        self.distancefunc = LogReg(self.stat_calc, seed=1)
         self.rng = np.random.RandomState(1)
 
     def test_distance(self):

From 59d252aaf6ef70a520fec71eff59d85d46188eaf Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 11:11:41 +0100
Subject: [PATCH 063/106] Rename files

---
 ...ple.py => pmcabc_gaussian_model_simple.py} |  2 +-
 ...ple.py => pmcabc_gaussian_model_simple.py} |  2 +-
 ...ple.py => pmcabc_gaussian_model_simple.py} |  2 +-
 ...ple.py => pmcabc_gaussian_model_simple.py} | 20 +++++++++----------
 4 files changed, 13 insertions(+), 13 deletions(-)
 rename examples/extensions/models/gaussian_R/{pmcabc-gaussian_model_simple.py => pmcabc_gaussian_model_simple.py} (98%)
 rename examples/extensions/models/gaussian_cpp/{pmcabc-gaussian_model_simple.py => pmcabc_gaussian_model_simple.py} (98%)
 rename examples/extensions/models/gaussian_f90/{pmcabc-gaussian_model_simple.py => pmcabc_gaussian_model_simple.py} (98%)
 rename examples/extensions/models/gaussian_python/{pmcabc-gaussian_model_simple.py => pmcabc_gaussian_model_simple.py} (93%)

diff --git a/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
similarity index 98%
rename from examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
rename to examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
index b5b7d12e..1fc5ac1c 100644
--- a/examples/extensions/models/gaussian_R/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
@@ -103,7 +103,7 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define backend
     from abcpy.backends import BackendDummy as Backend
diff --git a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
similarity index 98%
rename from examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
rename to examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
index 8e62dc54..57dd0b8c 100644
--- a/examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
@@ -94,7 +94,7 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define backend
     from abcpy.backends import BackendDummy as Backend
diff --git a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
similarity index 98%
rename from examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
rename to examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
index 05cb58ed..0dc1e07a 100644
--- a/examples/extensions/models/gaussian_f90/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
@@ -93,7 +93,7 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define kernel
     from abcpy.perturbationkernel import DefaultKernel
diff --git a/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
similarity index 93%
rename from examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
rename to examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
index 23815c2f..dfc92069 100644
--- a/examples/extensions/models/gaussian_python/pmcabc-gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
@@ -94,7 +94,7 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define kernel
     from abcpy.perturbationkernel import DefaultKernel
@@ -141,15 +141,15 @@ def analyse_journal(journal):
 
 
 # this code is for testing purposes only and not relevant to run the example
-# import unittest
-#
-#
-# class ExampleExtendModelGaussianPython(unittest.TestCase):
-#     def test_example(self):
-#         journal = infer_parameters()
-#         test_result = journal.posterior_mean()[0]
-#         expected_result = 177.02
-#         self.assertLess(abs(test_result - expected_result), 2.)
+import unittest
+
+
+class ExampleExtendModelGaussianPython(unittest.TestCase):
+    def test_example(self):
+        journal = infer_parameters()
+        test_result = journal.posterior_mean()[0]
+        expected_result = 177.02
+        self.assertLess(abs(test_result - expected_result), 2.)
 
 
 if __name__ == "__main__":

From 641a236d58719b0bde03659a97c07d4dbe0b47ac Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 15:53:58 +0100
Subject: [PATCH 064/106] Reorganize examples and add tests for that

---
 .travis.yml                                   |  2 +
 abcpy/distances.py                            |  5 +-
 .../approx_lhd/pmc_hierarchical_models.py     | 30 ++++--
 examples/backends/README.md                   |  6 +-
 .../backends/apache_spark/pmcabc_gaussian.py  | 33 ++-----
 examples/backends/dummy/pmcabc_gaussian.py    | 41 ++++----
 examples/backends/mpi/pmcabc_gaussian.py      | 47 ++++++----
 .../models/gaussian_R/gaussian_model.R        |  3 +-
 .../pmcabc_gaussian_model_simple.py           | 42 ++++++---
 .../pmcabc_gaussian_model_simple.py           | 43 +++++----
 .../pmcabc_gaussian_model_simple.py           | 40 ++++----
 .../pmcabc_gaussian_model_simple.py           | 41 ++++----
 .../pmcabc_perturbation_kernels.py            | 30 ++++--
 ...mcabc_inference_on_multiple_sets_of_obs.py | 30 ++++--
 .../randomforest_modelselections.py           |  9 +-
 .../pmcabc_gaussian_statistics_learning.py    | 28 ++++--
 tests/test_examples.py                        | 93 +++++++++++++++++++
 tests/test_examples_mpi.py                    | 35 +++++++
 18 files changed, 377 insertions(+), 181 deletions(-)
 create mode 100644 tests/test_examples.py
 create mode 100644 tests/test_examples_mpi.py

diff --git a/.travis.yml b/.travis.yml
index de8cf030..63ece1e8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,6 +15,8 @@ addons:
     - libmpich-dev
     - mpich
 install:
+- sudo apt-get install -y r-base  # install R for testing examples. Hope that works
+- pip install rpy2  # put this somewhere better
 - pip install -r requirements.txt
 - pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
diff --git a/abcpy/distances.py b/abcpy/distances.py
index dad729c6..96b3bc78 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -257,7 +257,8 @@ def __init__(self, statistics, seed=None):
         self.s1 = None
         self.data_set = None
         self.dataSame = False
-        self.seed = seed  # optional seed for the random split in the LogisticRegression classifier.
+        # seed is used for a RandomState for the random split in the LogisticRegression classifier:
+        self.rng = np.random.RandomState(seed=seed)
 
     def distance(self, d1, d2):
         """Calculates the distance between two datasets.
@@ -297,7 +298,7 @@ def distance(self, d1, d2):
 
         reg_inv = 1e5
         log_reg_model = linear_model.LogisticRegression(C=reg_inv, penalty='l1', max_iter=1000, solver='liblinear',
-                                                        random_state=self.seed)
+                                                        random_state=self.rng.randint(0, np.iinfo(np.uint32).max))
         log_reg_model.fit(training_set_features, training_set_labels)
         score = log_reg_model.score(training_set_features, training_set_labels)
         distance = 2.0 * (score - 0.5)
diff --git a/examples/approx_lhd/pmc_hierarchical_models.py b/examples/approx_lhd/pmc_hierarchical_models.py
index dcf5ef14..93361caf 100644
--- a/examples/approx_lhd/pmc_hierarchical_models.py
+++ b/examples/approx_lhd/pmc_hierarchical_models.py
@@ -2,10 +2,25 @@
 depend on some variables."""
 import logging
 
-logging.basicConfig(level=logging.INFO)
 
-
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # Observed data corresponding to model_1 defined below
     grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
                   4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
@@ -79,16 +94,13 @@ def infer_parameters():
     kernel = DefaultKernel([school_location, class_size, grade_without_additional_effects,
                             background, scholarship_without_additional_effects])
 
-    # Define sampling parameters
-    T, n_sample, n_samples_per_param = 3, 250, 20
-
     # Define sampler to use with the
     from abcpy.inferences import PMC
     sampler = PMC([final_grade, final_scholarship],
-                  [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel)
+                  [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel, seed=1)
 
     # Sample
-    journal = sampler.sample([grades_obs, scholarship_obs], T, n_sample, n_samples_per_param)
+    journal = sampler.sample([grades_obs, scholarship_obs], steps, n_sample, n_samples_per_param)
     return journal
 
 
@@ -115,5 +127,5 @@ def analyse_journal(journal):
 
 
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/backends/README.md b/examples/backends/README.md
index 2659d4c5..e0bf82f8 100644
--- a/examples/backends/README.md
+++ b/examples/backends/README.md
@@ -14,7 +14,7 @@ In this setup, the number of parallel processes is defined inside the Python cod
 
 Then, the parallel script can be run with: 
 
-    PYSPARK_PYTHON=python3 spark-submit pmcabc_gaussian.py 
+    PYSPARK_PYTHON=python3 spark-submit apache_spark/pmcabc_gaussian.py 
 
 where the environment variable `PYSPARK_PYTHON` is set as often Spark installations use Python2 by default.    
 
@@ -39,7 +39,7 @@ To run the files with MPI, the following command is required:
 
 For instance, to run `pmcabc_gaussian.py` with 4 tasks, we can run: 
 
-    mpirun -n 4 python3 pmcabc_gaussian.py
+    mpirun -n 4 python3 mpi/pmcabc_gaussian.py
 
 ### Nested parallelization with MPI
 
@@ -52,6 +52,6 @@ backend = Backend(process_per_model=2)
 
 Let's say we want to parallelize the model _n=3_ times. Therefore, we use the following command:
 
-    mpirun -n 7 python3 mpi_model_inferences.py
+    mpirun -n 7 python3 mpi/mpi_model_inferences.py
 
 as _(3*2) + 1 = 7_. Note that, in this scenario, using only 6 tasks overall leads to failure of the script due to how the tasks are assigned to the model instances.  
diff --git a/examples/backends/apache_spark/pmcabc_gaussian.py b/examples/backends/apache_spark/pmcabc_gaussian.py
index c108bacf..dbdab322 100644
--- a/examples/backends/apache_spark/pmcabc_gaussian.py
+++ b/examples/backends/apache_spark/pmcabc_gaussian.py
@@ -2,19 +2,17 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
-
 
 def setup_backend():
-    global backend
-
     import pyspark
     sc = pyspark.SparkContext()
     from abcpy.backends import BackendSpark as Backend
     backend = Backend(sc, parallelism=4)
+    return backend
 
 
-def infer_parameters():
+def infer_parameters(backend, steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
                   172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -44,17 +42,16 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -81,23 +78,7 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-import unittest
-import findspark
-
-
-class ExampleGaussianSparkTest(unittest.TestCase):
-    def setUp(self):
-        findspark.init()
-
-    def test_example(self):
-        setup_backend()
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 176.0
-        self.assertLess(abs(test_result - expected_result), 2.)
-
-
 if __name__ == "__main__":
-    setup_backend()
-    journal = infer_parameters()
+    backend = setup_backend()
+    journal = infer_parameters(backend, steps=1, logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/backends/dummy/pmcabc_gaussian.py b/examples/backends/dummy/pmcabc_gaussian.py
index e7889ea8..91f0a2e9 100644
--- a/examples/backends/dummy/pmcabc_gaussian.py
+++ b/examples/backends/dummy/pmcabc_gaussian.py
@@ -2,10 +2,27 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
 
 
-def infer_parameters():
+
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
                   172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -35,7 +52,7 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define kernel
     from abcpy.perturbationkernel import DefaultKernel
@@ -50,11 +67,9 @@ def infer_parameters():
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1)
 
-    # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -81,18 +96,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-# this code is for testing purposes only and not relevant to run the example
-# import unittest
-#
-#
-# class ExampleGaussianDummyTest(unittest.TestCase):
-#     def test_example(self):
-#         journal = infer_parameters()
-#         test_result = journal.posterior_mean()[0]
-#         expected_result = 176
-#         self.assertLess(abs(test_result - expected_result), 2.)
-
-
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/backends/mpi/pmcabc_gaussian.py b/examples/backends/mpi/pmcabc_gaussian.py
index 2145136f..447b7e83 100644
--- a/examples/backends/mpi/pmcabc_gaussian.py
+++ b/examples/backends/mpi/pmcabc_gaussian.py
@@ -2,20 +2,36 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
-
 
 def setup_backend():
-    global backend
-
     from abcpy.backends import BackendMPI as Backend
     backend = Backend()
     # The above line is equivalent to:
     # backend = Backend(process_per_model=1)
     # Notice: Models not parallelized by MPI should not be given process_per_model > 1
-
-
-def infer_parameters():
+    return backend
+
+
+def infer_parameters(backend, steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    backend
+        The parallelization backend
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
                   172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -45,17 +61,16 @@ def infer_parameters():
 
     # define distance
     from abcpy.distances import LogReg
-    distance_calculator = LogReg(statistics_calculator)
+    distance_calculator = LogReg(statistics_calculator, seed=42)
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -98,15 +113,7 @@ def setUpModule():
     setup_backend()
 
 
-# class ExampleGaussianMPITest(unittest.TestCase):
-#     def test_example(self):
-#         journal = infer_parameters()
-#         test_result = journal.posterior_mean()['mu']
-#         expected_result = 171.4343638312893
-#         self.assertLess(abs(test_result - expected_result), 2)
-
-
 if __name__ == "__main__":
-    setup_backend()
-    journal = infer_parameters()
+    backend = setup_backend()
+    journal = infer_parameters(backend, logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/extensions/models/gaussian_R/gaussian_model.R b/examples/extensions/models/gaussian_R/gaussian_model.R
index 18c99414..b30a7813 100644
--- a/examples/extensions/models/gaussian_R/gaussian_model.R
+++ b/examples/extensions/models/gaussian_R/gaussian_model.R
@@ -1,4 +1,5 @@
-simple_gaussian <- function(mu, sigma, k = 1) {
+simple_gaussian <- function(mu, sigma, k = 1, seed = seed) {
+  set.seed(seed)
   output <- rnorm(k, mu, sigma)
   return(output)
 }
\ No newline at end of file
diff --git a/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
index 1fc5ac1c..9594ad6e 100644
--- a/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
@@ -7,13 +7,15 @@
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
-logging.basicConfig(level=logging.INFO)
-
 rpy2.robjects.numpy2ri.activate()
-
-robjects.r('''
-       source('gaussian_model.R')
-''')
+try:
+    robjects.r('''
+       source('examples/extensions/models/gaussian_R/gaussian_model.R')
+    ''')
+except:
+    robjects.r('''
+           source('gaussian_model.R')
+    ''')
 
 r_simple_gaussian = robjects.globalenv['simple_gaussian']
 
@@ -61,7 +63,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState()):
         seed = rng.randint(np.iinfo(np.int32).max)
 
         # Do the actual forward simulation
-        vector_of_k_samples = list(r_simple_gaussian(mu, sigma, k))
+        vector_of_k_samples = list(r_simple_gaussian(mu, sigma, k, seed=seed))
 
         # Format the output to obey API
         result = [np.array([x]) for x in vector_of_k_samples]
@@ -74,7 +76,24 @@ def pdf(self, input_values, x):
         return pdf
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
              172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -111,13 +130,12 @@ def infer_parameters():
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([model], [distance_calculator], backend)
+    sampler = PMCABC([model], [distance_calculator], backend, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -145,5 +163,5 @@ def analyse_journal(journal):
 
 
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
index 57dd0b8c..970b6bf7 100644
--- a/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
@@ -2,12 +2,11 @@
 from numbers import Number
 
 import numpy as np
-from gaussian_model_simple import gaussian_model  # this is the file produced upon compiling
+from examples.extensions.models.gaussian_cpp.gaussian_model_simple import \
+    gaussian_model  # this is the file produced upon compiling
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
-logging.basicConfig(level=logging.INFO)
-
 
 class Gaussian(ProbabilisticModel, Continuous):
 
@@ -65,7 +64,24 @@ def pdf(self, input_values, x):
         return pdf
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
              172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -102,13 +118,12 @@ def infer_parameters():
 
     # define sampling scheme
     from abcpy.inferences import PMCABC
-    sampler = PMCABC([model], [distance_calculator], backend)
+    sampler = PMCABC([model], [distance_calculator], backend, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 100, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -135,18 +150,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-# this code is for testing purposes only and not relevant to run the example
-import unittest
-
-
-class ExampleExtendModelGaussianCpp(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 177.02
-        self.assertLess(abs(test_result - expected_result), 1.)
-
-
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
index 0dc1e07a..6a52e04b 100644
--- a/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
@@ -2,12 +2,10 @@
 from numbers import Number
 
 import numpy as np
-from gaussian_model_simple import gaussian_model
+from examples.extensions.models.gaussian_f90.gaussian_model_simple import gaussian_model
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
-logging.basicConfig(level=logging.INFO)
-
 
 class Gaussian(ProbabilisticModel, Continuous):
     def __init__(self, parameters, seed=None, name="gaussian"):
@@ -64,7 +62,24 @@ def pdf(self, input_values, x):
         return pdf
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
              172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -108,10 +123,9 @@ def infer_parameters():
     sampler = PMCABC([model], [distance_calculator], backend, kernel, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 100, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([y_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -138,18 +152,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-# this code is for testing purposes only and not relevant to run the example
-import unittest
-
-
-class ExampleExtendModelGaussianCpp(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 177.02
-        self.assertLess(abs(test_result - expected_result), 1.)
-
-
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
index dfc92069..d6a8d13b 100644
--- a/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
+++ b/examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
@@ -5,12 +5,11 @@
 
 from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector
 
-logging.basicConfig(level=logging.INFO)
-
 
 class Gaussian(ProbabilisticModel, Continuous):
     """
-    This class is an re-implementation of the `abcpy.continuousmodels.Normal` for documentation purposes.
+    logging.basicConfig(level=logging_level)
+This class is an re-implementation of the `abcpy.continuousmodels.Normal` for documentation purposes.
     """
 
     def __init__(self, parameters, name='Gaussian'):
@@ -66,7 +65,24 @@ def pdf(self, input_values, x):
         return pdf
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     height_obs = [160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084,
                   172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017,
@@ -110,10 +126,9 @@ def infer_parameters():
     sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1)
 
     # sample from scheme
-    T, n_sample, n_samples_per_param = 3, 250, 10
     eps_arr = np.array([.75])
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -140,18 +155,6 @@ def analyse_journal(journal):
     new_journal = Journal.fromFile('experiments.jnl')
 
 
-# this code is for testing purposes only and not relevant to run the example
-import unittest
-
-
-class ExampleExtendModelGaussianPython(unittest.TestCase):
-    def test_example(self):
-        journal = infer_parameters()
-        test_result = journal.posterior_mean()[0]
-        expected_result = 177.02
-        self.assertLess(abs(test_result - expected_result), 2.)
-
-
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
index d6cc9e79..e765f2b1 100644
--- a/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
+++ b/examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
@@ -2,13 +2,28 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
-
 
 # we show here how to choose explicitly the perturbation kernel for the PMCABC algorithm
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=50, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 50.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # The data corresponding to model_1 defined below
     grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
                   4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
@@ -87,9 +102,6 @@ def infer_parameters():
     from abcpy.perturbationkernel import JointPerturbationKernel
     kernel = JointPerturbationKernel([kernel_1, kernel_2])
 
-    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
-    # n_samples_per_param is the number of simulated datasets for each posterior sample.
-    T, n_sample, n_samples_per_param = 3, 50, 10
     eps_arr = np.array([30])  # starting value of epsilon; the smaller, the slower the algorithm.
     # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
     # iteration from the observation
@@ -98,10 +110,10 @@ def infer_parameters():
     # Define sampler
     from abcpy.inferences import PMCABC
     sampler = PMCABC([final_grade, final_scholarship],
-                     [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel)
+                     [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel, seed=1)
 
     # Sample
-    journal = sampler.sample([grades_obs, scholarship_obs], T, eps_arr, n_sample, n_samples_per_param,
+    journal = sampler.sample([grades_obs, scholarship_obs], steps, eps_arr, n_sample, n_samples_per_param,
                              epsilon_percentile)
     return journal
 
@@ -129,5 +141,5 @@ def analyse_journal(journal):
 
 
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
index 54920d21..1f118b33 100644
--- a/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
+++ b/examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
@@ -2,14 +2,29 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
-
 """An example showing how to implement a bayesian network in ABCpy. We consider here two hierarchical models which 
 depend on a common set of parameters (with prior distributions) and for which we get two sets of observations. Inference
 on the parameters can be performed jointly."""
 
 
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=50, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 50.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # The data corresponding to model_1 defined below
     grades_obs = [3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368,
                   4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294,
@@ -84,9 +99,6 @@ def infer_parameters():
     kernel = DefaultKernel([school_budget, class_size, grade_without_additional_effects,
                             no_teacher, scholarship_without_additional_effects])
 
-    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
-    # n_samples_per_param is the number of simulated datasets for each posterior sample.
-    T, n_sample, n_samples_per_param = 3, 50, 10
     eps_arr = np.array([30])  # starting value of epsilon; the smaller, the slower the algorithm.
     # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
     # iteration from the observation
@@ -96,11 +108,11 @@ def infer_parameters():
     # calculators
     from abcpy.inferences import PMCABC
     sampler = PMCABC([final_grade, final_scholarship],
-                     [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel)
+                     [distance_calculator_final_grade, distance_calculator_final_scholarship], backend, kernel, seed=1)
 
     # Sample; again, here we pass the two sets of observations in a list
     journal = sampler.sample([grades_obs, scholarship_obs],
-                             T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+                             steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
     return journal
 
 
@@ -127,5 +139,5 @@ def analyse_journal(journal):
 
 
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/examples/modelselection/randomforest_modelselections.py b/examples/modelselection/randomforest_modelselections.py
index 67940da2..1eccd5d4 100644
--- a/examples/modelselection/randomforest_modelselections.py
+++ b/examples/modelselection/randomforest_modelselections.py
@@ -2,10 +2,9 @@
 
 from abcpy.modelselections import RandomForest
 
-logging.basicConfig(level=logging.INFO)
 
-
-def infer_model():
+def infer_model(logging_level=logging.WARN):
+    logging.basicConfig(level=logging_level)
     # define observation for true parameters mean=170, std=15
     y_obs = [160.82499176]
 
@@ -35,7 +34,7 @@ def infer_model():
     modelselection = RandomForest(model_array, statistics_calculator, backend, seed=1)
 
     # Choose the correct model
-    model = modelselection.select_model(y_obs, n_samples=100, n_samples_per_param=1)
+    model = modelselection.select_model(y_obs, n_samples=100, n_samples_per_param=1, )
 
     # Compute the posterior probability of the chosen model
     model_prob = modelselection.posterior_probability(y_obs)
@@ -44,5 +43,5 @@ def infer_model():
 
 
 if __name__ == "__main__":
-    model, model_prob = infer_model()
+    model, model_prob = infer_model(logging_level=logging.INFO)
     print(f"The correct model is {model.name} with estimated posterior probability {model_prob[0]}.")
diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
index 947d2802..387f7207 100644
--- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
+++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
@@ -2,10 +2,25 @@
 
 import numpy as np
 
-logging.basicConfig(level=logging.INFO)
 
-
-def infer_parameters():
+def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
+    """Perform inference for this example.
+
+    Parameters
+    ----------
+    steps : integer, optional
+        Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
+    n_samples : integer, optional
+        Number of posterior samples to generate. The default value is 250.
+    n_samples_per_param : integer, optional
+        Number of data points in each simulated data set. The default value is 10.
+
+    Returns
+    -------
+    abcpy.output.Journal
+        A journal containing simulation results, metadata and optionally intermediate results.
+    """
+    logging.basicConfig(level=logging_level)
     # define backend
     # Note, the dummy backend does not parallelize the code!
     from abcpy.backends import BackendDummy as Backend
@@ -68,14 +83,11 @@ def infer_parameters():
     from abcpy.inferences import PMCABC
     sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1)
 
-    # Define sampling parameters: T is the number of iterations of PMCABC; n_sample is the number of posterior samples;
-    # n_samples_per_param is the number of simulated datasets for each posterior sample.
-    T, n_sample, n_samples_per_param = 3, 10, 10
     eps_arr = np.array([500])  # starting value of epsilon; the smaller, the slower the algorithm.
     # at each iteration, take as epsilon the epsilon_percentile of the distances obtained by simulations at previous
     # iteration from the observation
     epsilon_percentile = 10
-    journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
+    journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile)
 
     return journal
 
@@ -103,5 +115,5 @@ def analyse_journal(journal):
 
 
 if __name__ == "__main__":
-    journal = infer_parameters()
+    journal = infer_parameters(logging_level=logging.INFO)
     analyse_journal(journal)
diff --git a/tests/test_examples.py b/tests/test_examples.py
new file mode 100644
index 00000000..88c0ef53
--- /dev/null
+++ b/tests/test_examples.py
@@ -0,0 +1,93 @@
+"""Tests here the examples which do not require parallelization."""
+
+import unittest
+
+
+class ExampleApproxLhdTest(unittest.TestCase):
+    def test_pmc(self):
+        from examples.approx_lhd.pmc_hierarchical_models import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["school_location"]
+        expected_result = 0.2566394909510058
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+class ExampleBackendsTest(unittest.TestCase):
+    def test_dummy(self):
+        from examples.backends.dummy.pmcabc_gaussian import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 175.00683044068612
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+class ExampleExtensionsModelsTest(unittest.TestCase):
+    def test_cpp(self):
+        from examples.extensions.models.gaussian_cpp.pmcabc_gaussian_model_simple import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 173.74453347475725
+        self.assertAlmostEqual(test_result, expected_result)
+
+    def test_f90(self):
+        from examples.extensions.models.gaussian_f90.pmcabc_gaussian_model_simple import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 173.84265330966315
+        self.assertAlmostEqual(test_result, expected_result)
+
+    def test_python(self):
+        from examples.extensions.models.gaussian_python.pmcabc_gaussian_model_simple import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 175.00683044068612
+        self.assertAlmostEqual(test_result, expected_result)
+
+    def test_R(self):
+        import os
+        print(os.getcwd())
+        from examples.extensions.models.gaussian_R.pmcabc_gaussian_model_simple import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 173.4192372459506
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+class ExampleExtensionsPerturbationKernelsTest(unittest.TestCase):
+    def test_pmcabc_perturbation_kernel(self):
+        from examples.extensions.perturbationkernels.pmcabc_perturbation_kernels import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["schol_without_additional_effects"]
+        expected_result = 1.9492397683665226
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+class ExampleHierarchicalModelsTest(unittest.TestCase):
+    def test_pmcabc(self):
+        from examples.hierarchicalmodels.pmcabc_inference_on_multiple_sets_of_obs import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["schol_without_additional_effects"]
+        expected_result = 1.9492397683665226
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+class ExampleModelSelectionTest(unittest.TestCase):
+    def test_random_forest(self):
+        from examples.modelselection.randomforest_modelselections import infer_model
+        model, model_prob = infer_model()
+        expected_result = 0.8704000000000001
+        # this is not fully reproducible, there are some fluctuations in the estimated value
+        self.assertAlmostEqual(model_prob[0], expected_result, delta=0.05)
+
+
+class ExampleStatisticsLearningTest(unittest.TestCase):
+    def test_pmcabc(self):
+        from examples.statisticslearning.pmcabc_gaussian_statistics_learning import infer_parameters
+        journal = infer_parameters(steps=1, n_sample=50)
+        test_result = journal.posterior_mean()["mu"]
+        expected_result = 172.52136853079725
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/test_examples_mpi.py b/tests/test_examples_mpi.py
new file mode 100644
index 00000000..e7f6af83
--- /dev/null
+++ b/tests/test_examples_mpi.py
@@ -0,0 +1,35 @@
+"""Tests here example with MPI."""
+
+import unittest
+
+from abcpy.backends import BackendMPI
+
+
+def setUpModule():
+    '''
+    If an exception is raised in a setUpModule then none of
+    the tests in the module will be run.
+
+    This is useful because the teams run in a while loop on initialization
+    only responding to the scheduler's commands and will never execute anything else.
+
+    On termination of scheduler, the teams call quit() that raises a SystemExit().
+    Because of the behaviour of setUpModule, it will not run any unit tests
+    for the team and we now only need to write unit-tests from the scheduler's
+    point of view.
+    '''
+    global backend_mpi
+    backend_mpi = BackendMPI()
+
+
+class ExampleGaussianMPITest(unittest.TestCase):
+    def test_example(self):
+        from examples.backends.mpi.pmcabc_gaussian import infer_parameters
+        journal = infer_parameters(backend_mpi, steps=3, n_sample=50)
+        test_result = journal.posterior_mean()['mu']
+        expected_result = 174.94717012502286
+        self.assertAlmostEqual(test_result, expected_result)
+
+
+if __name__ == '__main__':
+    unittest.main()

From 455289faefe30898e48add91a69d14f825fbc934 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 15:54:53 +0100
Subject: [PATCH 065/106] Update Makefile: add example tests in coverage

---
 Makefile | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/Makefile b/Makefile
index 009e2e03..3857b4a8 100644
--- a/Makefile
+++ b/Makefile
@@ -24,33 +24,43 @@ $(MAKEDIRS):
 test: unittest unittest_mpi exampletest exampletest_mpi doctest
 
 unittest:
-	echo "Running standard unit tests.."
+	@echo "Running standard unit tests.."
 	python3 -m unittest discover -s tests -v -p "*_tests.py" || (echo "Error in standard unit tests."; exit 1)
 
 unittest_mpi:
-	echo "Running MPI backend unit tests.."
+	@echo "Running MPI backend unit tests.."
 	mpirun -np 2 python3 -m unittest discover -s tests -v -p "backend_tests_mpi.py" || (echo "Error in MPI unit tests."; exit 1)
 	mpirun -np 3 python3 -m unittest discover -s tests -v -p "backend_tests_mpi_model_mpi.py" || (echo "Error in MPI unit tests."; exit 1)
 
 exampletest: $(MAKEDIRS)
-	echo "Testing standard examples.."
-	python3 -m unittest discover -s examples -v -p "*.py" || (echo "Error in example tests."; exit 1)
+	@echo "Testing standard examples.."
+	python3 -m unittest -v tests/test_examples.py || (echo "Error in example tests."; exit 1)
 
 exampletest_mpi:
-	echo "Testing MPI backend examples.."
-	mpirun -np 2 python3 -m unittest -v examples/backends/mpi/pmcabc_gaussian.py || (echo "Error in MPI example tests."; exit 1)
+	@echo "Testing MPI backend examples.."
+	mpirun -np 2 python3 -m unittest -v tests/test_examples_mpi.py || (echo "Error in MPI example tests."; exit 1)
 
 doctest:
 	make -C doc html || (echo "Error in documentation generator."; exit 1)
 
-coveragetest:
+coveragetest: $(MAKEDIRS)  # compile models here as well as we check them for codecov as well.
 	command -v coverage >/dev/null 2>&1 || { echo >&2 "Python package 'coverage' has to been installed. Please, run 'pip3 install coverage'."; exit;}
+	# unittests
 	@- $(foreach TEST, $(UNITTESTS), \
 		echo === Testing code coverage: $(TEST); \
 		coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest $(TEST); \
 	)
+#	 unittest_mpi
+	@echo === Testing code coverage: tests/backend_tests_mpi.py
 	mpirun -np 2 coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest tests/backend_tests_mpi.py
-	mpirun -np 3 python3 -m unittest discover -s tests -v -p "backend_tests_mpi_model_mpi.py" || (echo "Error in MPI unit tests."; exit 1)
+	@echo === Testing code coverage: tests/backend_tests_mpi_model_mpi.py
+	mpirun -np 3 coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest tests/backend_tests_mpi_model_mpi.py
+	# exampletest
+	@echo === Testing code coverage: tests/test_examples.py
+	@coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest tests/test_examples.py
+	# exampletest_mpi
+	@echo === Testing code coverage: tests/examples_tests_mpi.py
+	mpirun -np 2 coverage run -a --branch --source abcpy --omit \*__init__.py -m unittest -v tests/test_examples_mpi.py
 	coverage html -d build/testcoverage
 	coverage report
 	@echo

From de88ce54c4b1b66ca400b5417904e85c898c3e60 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 16:17:27 +0100
Subject: [PATCH 066/106] Put back mpi in requirements.txt and rename torch
 requirement

---
 .travis.yml                                            |  1 -
 README.md                                              |  7 ++++---
 doc/source/installation.rst                            | 10 +++++-----
 requirements.txt                                       |  2 ++
 ...quirements.txt => neural_networks_requirements.txt} |  0
 5 files changed, 11 insertions(+), 9 deletions(-)
 rename requirements/{optional-requirements.txt => neural_networks_requirements.txt} (100%)

diff --git a/.travis.yml b/.travis.yml
index 63ece1e8..758a652f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,7 +18,6 @@ install:
 - sudo apt-get install -y r-base  # install R for testing examples. Hope that works
 - pip install rpy2  # put this somewhere better
 - pip install -r requirements.txt
-- pip install -r requirements/backend-mpi.txt
 - pip install -r requirements/backend-spark.txt
 - pip install -r requirements/optional-requirements.txt
 script:
diff --git a/README.md b/README.md
index 142d4363..79c25965 100644
--- a/README.md
+++ b/README.md
@@ -44,10 +44,11 @@ ABCpy can be installed from `pip`:
 
 Check [here](https://abcpy.readthedocs.io/en/latest/installation.html) for more details.
 
-Basic requirements are listed in `requirements.txt`. Additional packages are required for additional features: 
+Basic requirements are listed in `requirements.txt`. That also includes packages required for MPI parallelization there, which is very often used. However, we also provide support for parallelization with Apache Spark (see below).
+ 
+ Additional packages are required for additional features: 
 
-- `torch` is needed in order to use neural networks to learn summary statistics. It can be installed by running `pip install -r requirements/optional-requirements.txt`
-- In order to use MPI for parallelization, `mpi4py` and `cloudpickle` are required; install them by `pip install -r requirements/backend-mpi.txt`  
+- `torch` is needed in order to use neural networks to learn summary statistics. It can be installed by running `pip install -r requirements/neural_networks_requirements.txt`
 - In order to use Apache Spark for parallelization, `findspark` and `pyspark` are required; install them by `pip install -r requirements/backend-spark.txt`  
 
 ## Troubleshooting `mpi4py` installation
diff --git a/doc/source/installation.rst b/doc/source/installation.rst
index e0e62207..22e1f832 100644
--- a/doc/source/installation.rst
+++ b/doc/source/installation.rst
@@ -45,14 +45,14 @@ Requirements
 
 
 Basic requirements are listed in ``requirements.txt`` in the repository (`click here
-<https://github.com/eth-cscs/abcpy/blob/master/requirements.txt>`_). Additional packages are required for additional features:
+<https://github.com/eth-cscs/abcpy/blob/master/requirements.txt>`_). That also includes packages required for MPI parallelization there, which is very often used. However, we also provide support for parallelization with Apache Spark (see below).
+
+Additional packages are required for additional features:
 
-- ``torch`` is needed in order to use neural networks to learn summary statistics. It can be installed by running: ::
 
-    pip install -r requirements/optional-requirements.txt
-- In order to use MPI for parallelization, ``mpi4py`` and ``cloudpickle`` are required; install them by: ::
+- ``torch`` is needed in order to use neural networks to learn summary statistics. It can be installed by running: ::
 
-    pip install -r requirements/backend-mpi.txt
+    pip install -r requirements/neural_networks_requirements.txt
 - In order to use Apache Spark for parallelization, ``findspark`` and ``pyspark`` are required; install them by: ::
 
     pip install -r requirements/backend-spark.txt
diff --git a/requirements.txt b/requirements.txt
index f028e251..d09c5a54 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,5 +5,7 @@ glmnet>=2.2.1
 sphinx
 sphinx_rtd_theme 
 coverage
+mpi4py
+cloudpickle
 matplotlib
 tqdm
\ No newline at end of file
diff --git a/requirements/optional-requirements.txt b/requirements/neural_networks_requirements.txt
similarity index 100%
rename from requirements/optional-requirements.txt
rename to requirements/neural_networks_requirements.txt

From 8ba66d83daf43fa1ff730c8fcb0bd39e66c0da8d Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 16:30:19 +0100
Subject: [PATCH 067/106] Add binder environment.yml

---
 environment.yml | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 environment.yml

diff --git a/environment.yml b/environment.yml
new file mode 100644
index 00000000..e4a535a3
--- /dev/null
+++ b/environment.yml
@@ -0,0 +1,6 @@
+channels:
+- conda-forge
+dependencies:
+- openmpi
+- mpi4py
+- numpy
\ No newline at end of file

From 55b3f77073a5dfe48e8f465597a33b72625f7aca Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 17:02:35 +0100
Subject: [PATCH 068/106] Add stages in travis: deploy only if all tests are
 fine

---
 .travis.yml | 52 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 19 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 8bfecc9c..a5801fe8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,9 @@
 dist: xenial
 language: python
+stages:
+  - name: test
+  - name: deploy
+    if: tag IS present AND branch = master
 addons:
   apt:
     sources:
@@ -12,26 +16,48 @@ addons:
     - swig
     - libmpich-dev
     - mpich
-matrix:
+jobs:
     include:
         # Unit tests on different python versions, all on Ubuntu
-        - python: "3.6"
+        - stage: test
+          name: "Python 3.6"
+          python: "3.6"
           env:
             - UNIT_TEST=true
-        - python: "3.7"
+        - name: "Python 3.7"
+          python: "3.7"
           env:
             - UNIT_TEST=true
-        - python: "3.8"
+        - name: "Python 3.8"
+          python: "3.8"
           env:
             - UNIT_TEST=true
-
       # Test coverage and without Pytorch for a single version
-        - python: "3.8"
+        - name: "Coverage"
+          python: "3.8"
           env:
             - COVERAGE=true
-        - python: "3.8"
+        - name: "No pytorch"
+          python: "3.8"
           env:
             - NO_PYTORCH=true
+        - stage: deploy
+          script:
+            - echo "Required dummy override of default 'script' in .travis.yml."
+          after_success:
+            - echo "Required dummy override of default 'after_success' in .travis.yml."
+          before_deploy:
+          - make clean
+          - mkdir dist
+          deploy:
+          - provider: pypi
+            user: mschoengens
+            password:
+              secure: tLopsTVkRfraHb/T1qfNvXk4L3StqpqFTflK0iAq/V+WSdARy7PDccj3P13aDo+Qvd2XYDPTSIVTveTOSHj46oser7+OmqrUYH9jQt681bmJ5aooHhw+3+NHa+fVBxMgzvCqJ+4Gvbf+3eDKowXICfPlTj5UrEil7s1jv91bSIm0HdI+mLyg1YstHOGt0O2Y6QEDPyEVRmFtyq7hB7EPheUvaJAfEl70LxV9fHiOuuQNcp9pnGRO6t9Sx4NIfIPIYzSdBoLaMSwgjy6ua1wF4iyMdKaDhMSajYb2+fWY1iyDJnmFj0/olpYUiZTrfWfQqz2j+uGT/YbmfZmSCcBTQI9ixJCtawqExoZODSq34uzc+N61riXdLEMOroxMobeBhuNj+bykp1IKaE99vYL/q8ta5dID15MtWIjWbLDVYQTQPkJ7fWllyxqOVRwa2rN37QbCctPbKpCs7WvEE7mJAaWJuOprw0AYjd2IH76YULkzbk3nR/v1nwyM2hGTYjePAy6Ue9jPgfeu9jEWu23O4u7+KMa1+scuLRP4DB1nlMStixjAJdiPMIo4OrvAiC8+ocntgi8t9+Quu5N8deyr9nM1pvWQyaNuHt3Yxd5oey3Q5UMtQFRCl5IyQKMTKttBg2p2L4wd0RdfrLgJXWkw/s6SBIyylCCDROr5gMEnPfY=
+            distributions: "sdist bdist_wheel"
+            on:
+              tags: true
+              branch: master
 
 install:
 - pip install -r requirements.txt
@@ -46,15 +72,3 @@ script:
 - if [[ $COVERAGE == true ]]; then make coveragetest; fi;
 after_success:
 - if [[ $COVERAGE == true ]]; then bash <(curl -s https://codecov.io/bash); fi;
-before_deploy:
-- make clean
-- mkdir dist
-deploy:
-- provider: pypi
-  user: mschoengens
-  password:
-    secure: tLopsTVkRfraHb/T1qfNvXk4L3StqpqFTflK0iAq/V+WSdARy7PDccj3P13aDo+Qvd2XYDPTSIVTveTOSHj46oser7+OmqrUYH9jQt681bmJ5aooHhw+3+NHa+fVBxMgzvCqJ+4Gvbf+3eDKowXICfPlTj5UrEil7s1jv91bSIm0HdI+mLyg1YstHOGt0O2Y6QEDPyEVRmFtyq7hB7EPheUvaJAfEl70LxV9fHiOuuQNcp9pnGRO6t9Sx4NIfIPIYzSdBoLaMSwgjy6ua1wF4iyMdKaDhMSajYb2+fWY1iyDJnmFj0/olpYUiZTrfWfQqz2j+uGT/YbmfZmSCcBTQI9ixJCtawqExoZODSq34uzc+N61riXdLEMOroxMobeBhuNj+bykp1IKaE99vYL/q8ta5dID15MtWIjWbLDVYQTQPkJ7fWllyxqOVRwa2rN37QbCctPbKpCs7WvEE7mJAaWJuOprw0AYjd2IH76YULkzbk3nR/v1nwyM2hGTYjePAy6Ue9jPgfeu9jEWu23O4u7+KMa1+scuLRP4DB1nlMStixjAJdiPMIo4OrvAiC8+ocntgi8t9+Quu5N8deyr9nM1pvWQyaNuHt3Yxd5oey3Q5UMtQFRCl5IyQKMTKttBg2p2L4wd0RdfrLgJXWkw/s6SBIyylCCDROr5gMEnPfY=
-  distributions: "sdist bdist_wheel"
-  on:
-    tags: true
-    branch: master

From 5caeb53086caf0bc13cd9583e990c4d3cc847f89 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 17:07:08 +0100
Subject: [PATCH 069/106] Add further badges in README.md

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 9d61a5a2..ea3301e4 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,4 @@
-# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy) [![DOI](https://zenodo.org/badge/doi/10.1145/3093172.3093233.svg)](http://dx.doi.org/10.1145/3093172.3093233) [![GitHub license](https://img.shields.io/github/license/eth-cscs/abcpy.svg)](https://github.com/eth-cscs/abcpy/blob/master/LICENSE)
-
+# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy) [![DOI](https://zenodo.org/badge/doi/10.1145/3093172.3093233.svg)](http://dx.doi.org/10.1145/3093172.3093233) [![GitHub license](https://img.shields.io/github/license/eth-cscs/abcpy.svg)](https://github.com/eth-cscs/abcpy/blob/master/LICENSE) [![PyPI version shields.io](https://img.shields.io/pypi/v/abcpy.svg)](https://pypi.python.org/pypi/abcpy/) [![PyPI pyversions](https://img.shields.io/pypi/pyversions/abcpy.svg)](https://pypi.python.org/pypi/abcpy/)
 
 ABCpy is a scientific library written in Python for Bayesian uncertainty quantification in
 absence of likelihood function, which parallelizes existing approximate Bayesian computation (ABC) 

From 2ca4d047b3089a0edd69982c79ce07f3dd628455 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 30 Oct 2020 17:26:59 +0100
Subject: [PATCH 070/106] Fix requirements in travis

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 758a652f..ac0bb864 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,7 +19,7 @@ install:
 - pip install rpy2  # put this somewhere better
 - pip install -r requirements.txt
 - pip install -r requirements/backend-spark.txt
-- pip install -r requirements/optional-requirements.txt
+- pip install -r requirements/neural_networks_requirements.txt
 script:
 - make test
 before_deploy:

From 23499cd4c84b7d574100abe433f49d18e23a6b0c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 31 Oct 2020 10:29:48 +0100
Subject: [PATCH 071/106] Fix example test for f90: it looks like result is not
 reproducible when compiling on different machine

---
 tests/test_examples.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_examples.py b/tests/test_examples.py
index 88c0ef53..661df97b 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -33,8 +33,9 @@ def test_f90(self):
         from examples.extensions.models.gaussian_f90.pmcabc_gaussian_model_simple import infer_parameters
         journal = infer_parameters(steps=1, n_sample=50)
         test_result = journal.posterior_mean()["mu"]
+        # note that this result seem to change when compiling on different machines.
         expected_result = 173.84265330966315
-        self.assertAlmostEqual(test_result, expected_result)
+        self.assertAlmostEqual(test_result, expected_result, delta=3)
 
     def test_python(self):
         from examples.extensions.models.gaussian_python.pmcabc_gaussian_model_simple import infer_parameters

From 68b0a116a9cd9238ea20d50ce3bcbcc2dbc4d052 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 31 Oct 2020 10:59:23 +0100
Subject: [PATCH 072/106] Update ubuntu version to install newer R version for
 rpy2 library

---
 .travis.yml            | 6 +++---
 tests/test_examples.py | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index ac0bb864..76746dce 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,4 @@
-dist: xenial
+dist: bionic
 language: python
 python:
 - '3.7'
@@ -15,8 +15,8 @@ addons:
     - libmpich-dev
     - mpich
 install:
-- sudo apt-get install -y r-base  # install R for testing examples. Hope that works
-- pip install rpy2  # put this somewhere better
+- sudo apt-get install -y r-base  # install R for testing example
+- pip install rpy2  # install the rpy2 library for testing example with R
 - pip install -r requirements.txt
 - pip install -r requirements/backend-spark.txt
 - pip install -r requirements/neural_networks_requirements.txt
diff --git a/tests/test_examples.py b/tests/test_examples.py
index 661df97b..6df38ddc 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -33,7 +33,7 @@ def test_f90(self):
         from examples.extensions.models.gaussian_f90.pmcabc_gaussian_model_simple import infer_parameters
         journal = infer_parameters(steps=1, n_sample=50)
         test_result = journal.posterior_mean()["mu"]
-        # note that this result seem to change when compiling on different machines.
+        # note that the f90 example does not always yield the same result on some machines, even if it uses random seed
         expected_result = 173.84265330966315
         self.assertAlmostEqual(test_result, expected_result, delta=3)
 

From 54a16e7910afa3eef74dbc16289a751eca03650d Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 31 Oct 2020 14:01:25 +0100
Subject: [PATCH 073/106] Fix Python versions in setup.py

---
 setup.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index b6231410..18f9a09f 100644
--- a/setup.py
+++ b/setup.py
@@ -60,8 +60,9 @@
         'Development Status :: 4 - Beta',
 
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
     ],
 
     # What does your project relate to?

From 108ea6f9f407a86999f4063b71c9ea3bd6d2a5ea Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Sat, 31 Oct 2020 14:32:53 +0100
Subject: [PATCH 074/106] Fix wrong requirements name

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 87edca8b..1a433fed 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -64,7 +64,7 @@ install:
 - pip install rpy2  # install the rpy2 library for testing example with R
 - pip install -r requirements.txt
 - pip install -r requirements/backend-spark.txt
-- if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/neural_networks_requirements-requirements.txt; fi;
+- if [[ ! $NO_PYTORCH == true ]]; then pip install -r requirements/neural_networks_requirements.txt; fi;
 - if [[ $COVERAGE == true ]]; then pip install -r requirements/coverage.txt; fi;
 before_script:
 - python --version

From 8dcae97adab58692054cd28188fdd785ea837a71 Mon Sep 17 00:00:00 2001
From: Ritabrata Dutta <statrita2004@gmail.com>
Date: Mon, 2 Nov 2020 13:58:39 +0000
Subject: [PATCH 075/106] Delete multilevel.py

---
 abcpy/multilevel.py | 101 --------------------------------------------
 1 file changed, 101 deletions(-)
 delete mode 100644 abcpy/multilevel.py

diff --git a/abcpy/multilevel.py b/abcpy/multilevel.py
deleted file mode 100644
index ce1aa02d..00000000
--- a/abcpy/multilevel.py
+++ /dev/null
@@ -1,101 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-import numpy as np
-from glmnet import LogitNet
-from sklearn import linear_model
-
-
-class Multilevel(metaclass=ABCMeta):
-    """This abstract base class defines how the distance between the observed and
-    simulated data should be implemented.
-    """
-
-    @abstractmethod
-    def __init__(self, backend, data_thinner, criterion_calculator):
-        """The constructor of a sub-class must accept a non-optional data thinner and criterion
-        calculator as parameters.
-
-        Parameters
-        ----------
-        backend: abcpy.backend
-            Backend object
-        data_thinner : object
-            Object that operates on data and thins it
-        criterion_calculator: object
-            Object that operates on n_samples_per_param data and computes the criterion
-        """
-
-        self.bacend = backend
-        self.data_thinner = data_thinner
-        self.criterion_calculator = criterion_calculator
-
-        raise NotImplementedError
-
-    @abstractmethod
-    def compute(self, d, n_repeat):
-        """To be overwritten by any sub-class: should calculate the criterion for each
-        set of data_element in the lis data
-
-        Notes
-        -----
-        The data set d is an array-like structures that contain n data
-        points each.  An implementation of the distance function should work along
-        the following steps:
-
-        1. Transform both input sets dX = [ dX1, dX2, ..., dXn ] to sX = [sX1, sX2,
-        ..., sXn] using the statistics object. See _calculate_summary_stat method.
-
-        2. Calculate the mutual desired distance, here denoted by -, between the
-        statstics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
-
-        Important: any sub-class must not calculate the distance between data sets
-        d1 and d2 directly. This is the reason why any sub-class must be
-        initialized with a statistics object.
-
-        Parameters
-        ----------
-        d: Python list
-            Contains n data points.
-
-
-        Returns
-        -------
-        numpy.ndarray
-            The criterion calculated for each data point.
-        """
-
-        raise NotImplementedError
-
-    ## Simple_map and Flat_map: Python wrapper for nested parallelization
-    def simple_map(self, data, map_function):
-        data_pds = self.backend.parallelize(data)
-        result_pds = self.backend.map(map_function, data_pds)
-        result = self.backend.collect(result_pds)
-        main_result, counter = [list(t) for t in zip(*result)]
-        return main_result, counter
-
-    def flat_map(self, data, n_repeat, map_function):
-        # Create an array of data, with each data repeated n_repeat many times
-        repeated_data = np.repeat(data, n_repeat, axis=0)
-        # Create an see array
-        n_total = n_repeat * data.shape[0]
-        seed_arr = self.rng.randint(1, n_total * n_total, size=n_total, dtype=np.int32)
-        rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
-        # Create data and rng array
-        repeated_data_rng = [[repeated_data[ind,:],rng_arr[ind]] for ind in range(n_total)]
-        repeated_data_rng_pds = self.backend.parallelize(repeated_data_rng)
-        # Map the function on the data using the corresponding rng
-        repeated_data_result_pds = self.backend.map(map_function, repeated_data_rng_pds)
-        repeated_data_result = self.backend.collect(repeated_data_result_pds)
-        repeated_data, result = [list(t) for t in zip(*repeated_data_result)]
-        merged_result_data = []
-        for ind in range(0, data.shape[0]):
-            merged_result_data.append([[[result[np.int(i)][0][0] \
-                                         for i in
-                                         np.where(np.mean(repeated_data == data[ind, :], axis=1) == 1)[0]]],
-                                       data[ind, :]])
-        return merged_result_data
-
-
-class Prototype(Multilevel):
-    
\ No newline at end of file

From 3ec8a7a24cb54bc7e0267663d8ed8fec0802d573 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 2 Nov 2020 15:55:16 +0100
Subject: [PATCH 076/106] Remove useless multilevel.py file

---
 abcpy/multilevel.py | 98 ---------------------------------------------
 1 file changed, 98 deletions(-)
 delete mode 100644 abcpy/multilevel.py

diff --git a/abcpy/multilevel.py b/abcpy/multilevel.py
deleted file mode 100644
index 12ad8326..00000000
--- a/abcpy/multilevel.py
+++ /dev/null
@@ -1,98 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-import numpy as np
-
-
-class Multilevel(metaclass=ABCMeta):
-    """This abstract base class defines how the distance between the observed and
-    simulated data should be implemented.
-    """
-
-    @abstractmethod
-    def __init__(self, backend, data_thinner, criterion_calculator):
-        """The constructor of a sub-class must accept a non-optional data thinner and criterion
-        calculator as parameters.
-
-        Parameters
-        ----------
-        backend: abcpy.backend
-            Backend object
-        data_thinner : object
-            Object that operates on data and thins it
-        criterion_calculator: object
-            Object that operates on n_samples_per_param data and computes the criterion
-        """
-
-        self.bacend = backend
-        self.data_thinner = data_thinner
-        self.criterion_calculator = criterion_calculator
-
-        raise NotImplementedError
-
-    @abstractmethod
-    def compute(self, d, n_repeat):
-        """To be overwritten by any sub-class: should calculate the criterion for each
-        set of data_element in the lis data
-
-        Notes
-        -----
-        The data set d is an array-like structures that contain n data
-        points each.  An implementation of the distance function should work along
-        the following steps:
-
-        1. Transform both input sets dX = [ dX1, dX2, ..., dXn ] to sX = [sX1, sX2,
-        ..., sXn] using the statistics object. See _calculate_summary_stat method.
-
-        2. Calculate the mutual desired distance, here denoted by -, between the
-        statstics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
-
-        Important: any sub-class must not calculate the distance between data sets
-        d1 and d2 directly. This is the reason why any sub-class must be
-        initialized with a statistics object.
-
-        Parameters
-        ----------
-        d: Python list
-            Contains n data points.
-
-
-        Returns
-        -------
-        numpy.ndarray
-            The criterion calculated for each data point.
-        """
-
-        raise NotImplementedError
-
-    ## Simple_map and Flat_map: Python wrapper for nested parallelization
-    def simple_map(self, data, map_function):
-        data_pds = self.backend.parallelize(data)
-        result_pds = self.backend.map(map_function, data_pds)
-        result = self.backend.collect(result_pds)
-        main_result, counter = [list(t) for t in zip(*result)]
-        return main_result, counter
-
-    def flat_map(self, data, n_repeat, map_function):
-        # Create an array of data, with each data repeated n_repeat many times
-        repeated_data = np.repeat(data, n_repeat, axis=0)
-        # Create an see array
-        n_total = n_repeat * data.shape[0]
-        seed_arr = self.rng.randint(1, n_total * n_total, size=n_total, dtype=np.int32)
-        rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr])
-        # Create data and rng array
-        repeated_data_rng = [[repeated_data[ind, :], rng_arr[ind]] for ind in range(n_total)]
-        repeated_data_rng_pds = self.backend.parallelize(repeated_data_rng)
-        # Map the function on the data using the corresponding rng
-        repeated_data_result_pds = self.backend.map(map_function, repeated_data_rng_pds)
-        repeated_data_result = self.backend.collect(repeated_data_result_pds)
-        repeated_data, result = [list(t) for t in zip(*repeated_data_result)]
-        merged_result_data = []
-        for ind in range(0, data.shape[0]):
-            merged_result_data.append([[[result[np.int(i)][0][0] \
-                                         for i in
-                                         np.where(np.mean(repeated_data == data[ind, :], axis=1) == 1)[0]]],
-                                       data[ind, :]])
-        return merged_result_data
-
-
-class Prototype(Multilevel):

From 0e7157abcc83126293ab43a405905df7a9eb8258 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 2 Nov 2020 16:43:13 +0100
Subject: [PATCH 077/106] Fix some typos

---
 abcpy/backends/mpi.py        |  6 ++---
 abcpy/continuousmodels.py    |  8 +++---
 abcpy/graphtools.py          |  2 +-
 abcpy/inferences.py          | 48 ++++++++++++++++++------------------
 abcpy/probabilisticmodels.py |  2 +-
 abcpy/statistics.py          |  2 +-
 6 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/abcpy/backends/mpi.py b/abcpy/backends/mpi.py
index c458c9bb..30e163f6 100644
--- a/abcpy/backends/mpi.py
+++ b/abcpy/backends/mpi.py
@@ -241,7 +241,7 @@ def orchestrate_map(self, pds_id):
 
         # While we have some ranks that haven't finished
         while sum(is_map_done) < self.mpimanager.get_scheduler_size():
-            # Wait for a reqest from anyone
+            # Wait for a request from anyone
             data_request = self.mpimanager.get_scheduler_communicator().recv(
                 source=MPI.ANY_SOURCE,
                 tag=MPI.ANY_TAG,
@@ -535,7 +535,7 @@ def __leader_run(self):
                 # Func sent before and not during for performance reasons
                 pds_res = self.map(function_packed)
 
-                # Store the result in a newly gnerated PDS pds_id
+                # Store the result in a newly generated PDS pds_id
                 self.pds_store[pds_res.pds_id] = pds_res
 
             elif op == self.OP_BROADCAST:
@@ -618,7 +618,7 @@ def map(self, function_packed):
             if data_chunks is None:
                 break
 
-            # Accumulate the indicess and *processed* chunks
+            # Accumulate the indices and *processed* chunks
             for chunk in data_chunks:
                 data_index, data_item = chunk
                 res = self.__leader_run_function(function_packed, data_item)
diff --git a/abcpy/continuousmodels.py b/abcpy/continuousmodels.py
index 3b31760f..898fb592 100644
--- a/abcpy/continuousmodels.py
+++ b/abcpy/continuousmodels.py
@@ -187,8 +187,8 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
 
     def get_output_dimension(self):
         return 1
-        ## Why does the following not work here?
-        ## return self._dimension
+        # Why does the following not work here?
+        # return self._dimension
 
     def pdf(self, input_values, x):
         """
@@ -284,8 +284,8 @@ def _check_output(self, parameters):
 
     def get_output_dimension(self):
         return 1
-        ## Why does the following not work here?
-        ## return self._dimension
+        # Why does the following not work here?
+        # return self._dimension
 
     def pdf(self, input_values, x):
         """
diff --git a/abcpy/graphtools.py b/abcpy/graphtools.py
index f7e80905..4ae8c685 100644
--- a/abcpy/graphtools.py
+++ b/abcpy/graphtools.py
@@ -137,7 +137,7 @@ def _recursion_pdf_of_prior(self, models, parameters, mapping=None, is_root=True
         if is_root:
             mapping, garbage_index = self._get_mapping()
 
-        # The pdf of each root model is first calculated seperately
+        # The pdf of each root model is first calculated separately
         result = [1.] * len(models)
 
         for i, model in enumerate(models):
diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index ee8f1c87..07b748b6 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -1160,11 +1160,11 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
         sample_array[0] = n_samples
         sample_array[1:] = n_update
 
-        ## Acceptance counter to determine the resampling step
+        # Acceptance counter to determine the resampling step
         accept = 0
         samples_until = 0
 
-        ## Counter whether broken preemptively
+        # Counter whether broken preemptively
         broken_preemptively = False
 
         for aStep in range(0, steps):
@@ -1173,7 +1173,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                 accepted_parameters = journal.get_accepted_parameters(-1)
                 accepted_weights = journal.get_weights(-1)
 
-                # Broadcast Accepted parameters and Accedpted weights
+                # Broadcast Accepted parameters and Accepted weights
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                                   accepted_weights=accepted_weights)
 
@@ -1279,23 +1279,23 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                 smooth_distances = smooth_distances[index_resampled]
                 distances = distances[index_resampled]
 
-                ## Update U and epsilon:
+                # Update U and epsilon:
                 epsilon = epsilon * (1 - delta)
                 U = np.mean(smooth_distances)
                 epsilon = self._schedule(U, v)
 
-                ## Print effective sampling size
+                # Print effective sampling size
                 self.logger.info('Resampling: Effective sampling size: ' + str(1 / sum(pow(weight / sum(weight), 2))))
                 accept = 0
                 samples_until = 0
 
-                ## Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
+                # Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
                 # Broadcast Accepted parameters and add to journal
                 self.logger.info("Broadcast Accepted parameters and add to journal")
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
                                                                   accepted_parameters=accepted_parameters)
-                # Compute Accepetd Kernel parameters and broadcast them
-                self.logger.debug("Compute Accepetd Kernel parameters and broadcast them")
+                # Compute Accepted Kernel parameters and broadcast them
+                self.logger.debug("Compute Accepted Kernel parameters and broadcast them")
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
                     kernel_parameters.append(
@@ -1309,7 +1309,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
                 if full_output == 1 and aStep <= steps - 1:
-                    ## Saving intermediate configuration to output journal.
+                    # Saving intermediate configuration to output journal.
                     self.logger.info('Saving after resampling')
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                     journal.add_weights(copy.deepcopy(accepted_weights))
@@ -1318,11 +1318,11 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                     journal.add_user_parameters(names_and_parameters)
                     journal.number_of_simulations.append(self.simulation_counter)
             else:
-                ## Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
+                # Compute and broadcast accepted parameters, accepted kernel parameters and accepted Covariance matrix
                 # Broadcast Accepted parameters
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
                                                                   accepted_parameters=accepted_parameters)
-                # Compute Accepetd Kernel parameters and broadcast them
+                # Compute Accepted Kernel parameters and broadcast them
                 kernel_parameters = []
                 for kernel in self.kernel.kernels:
                     kernel_parameters.append(
@@ -1335,7 +1335,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_cov_mats=accepted_cov_mats)
 
                 if full_output == 1 and aStep <= steps - 1:
-                    ## Saving intermediate configuration to output journal.
+                    # Saving intermediate configuration to output journal.
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                     journal.add_weights(copy.deepcopy(accepted_weights))
                     journal.add_distances(copy.deepcopy(distances))
@@ -1475,9 +1475,9 @@ def _accept_parameter(self, data, npc=None):
                 acceptance = rng.binomial(1, np.exp(-distance / self.epsilon), 1)
             acceptance = 1
         else:
-            ## Select one arbitrary particle:
+            # Select one arbitrary particle:
             index = rng.choice(self.n_samples, size=1)[0]
-            ## Sample proposal parameter and calculate new distance:
+            # Sample proposal parameter and calculate new distance:
             theta = self.accepted_parameters_manager.accepted_parameters_bds.value()[index]
 
             while True:
@@ -1492,14 +1492,14 @@ def _accept_parameter(self, data, npc=None):
             distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
             smooth_distance = self._smoother_distance([distance], self.all_distances_bds.value())
 
-            ## Calculate acceptance probability:
+            # Calculate acceptance probability:
             self.logger.debug("Calulate acceptance probability")
             ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(
                 self.model, self.accepted_parameters_manager.accepted_parameters_bds.value()[index])
             ratio_likelihood_prob = np.exp((self.smooth_distances_bds.value()[index] - smooth_distance) / self.epsilon)
             acceptance_prob = ratio_prior_prob * ratio_likelihood_prob
 
-            ## If accepted
+            # If accepted
             if rng.rand(1) < acceptance_prob:
                 acceptance = 1
             else:
@@ -1700,7 +1700,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch
             accepted_params_and_dist = sorted(accepted_params_and_dist, key=lambda x: x[0])
             distances, accepted_parameters = [list(t) for t in zip(*accepted_params_and_dist)]
 
-            # 3: Calculate and broadcast annealling parameters
+            # 3: Calculate and broadcast annealing parameters
             self.logger.debug("Calculate and broadcast annealling parameters.")
             temp_chain_length = self.chain_length
             if aStep > 0:
@@ -1842,7 +1842,7 @@ def _accept_parameter(self, rng_and_index, npc=None):
                 counter += 1
                 new_distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
-                ## Calculate acceptance probability:
+                # Calculate acceptance probability:
                 ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
                                                                                                              theta)
                 kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
@@ -1853,7 +1853,7 @@ def _accept_parameter(self, rng_and_index, npc=None):
                 acceptance_prob = min(1, ratio_prior_prob * ratio_likelihood_prob) * (
                         new_distance < self.anneal_parameter)
 
-                ## If accepted
+                # If accepted
                 if rng.binomial(1, acceptance_prob) == 1:
                     result_theta.append(perturbation_output[1])
                     result_distance.append(new_distance)
@@ -1907,7 +1907,7 @@ def _update_cov_mat(self, rng_t, npc=None):
             new_distance = self.distance.distance(self.accepted_parameters_manager.observations_bds.value(), y_sim)
 
             self.logger.debug("Calculate acceptance probability.")
-            ## Calculate acceptance probability:
+            # Calculate acceptance probability:
             ratio_prior_prob = self.pdf_of_prior(self.model, perturbation_output[1]) / self.pdf_of_prior(self.model,
                                                                                                          theta)
             kernel_numerator = self.kernel.pdf(mapping_for_kernels, self.accepted_parameters_manager,
@@ -2014,7 +2014,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, al
         epsilon_final : float, optional
             Terminal value of threshold, the default is 0.1
         const : float, optional
-             A constant to compute acceptance probabilty, the default is 0.01.
+             A constant to compute acceptance probability, the default is 0.01.
         covFactor : float, optional
             scaling parameter of the covariance matrix. The default value is 2.
         full_output: integer, optional
@@ -2156,7 +2156,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, al
                 journal.add_user_parameters(names_and_parameters)
                 journal.number_of_simulations.append(self.simulation_counter)
 
-            # 2: Compute acceptance probabilty and set R
+            # 2: Compute acceptance probability and set R
             self.logger.info("Compute acceptance probabilty and set R")
             prob_acceptance = sum(new_index) / (R * n_replenish)
             if prob_acceptance == 1 or prob_acceptance == 0:
@@ -2569,7 +2569,7 @@ def _accept_parameter(self, rng, npc=None):
         else:
             index = rng.choice(len(self.accepted_parameters_manager.accepted_weights_bds.value()), size=1,
                                p=self.accepted_parameters_manager.accepted_weights_bds.value().reshape(-1))
-            # trucate the normal to the bounds of parameter space of the model
+            # truncate the normal to the bounds of parameter space of the model
             # truncating the normal like this is fine: https://arxiv.org/pdf/0907.4010v1.pdf
             while True:
                 perturbation_output = self.perturb(index[0], rng=rng)
@@ -3011,7 +3011,7 @@ def _accept_parameter(self, rng_and_index, npc=None):
                 y_sim = self.simulate(self.n_samples_per_param, rng=rng, npc=npc)
                 counter += 1
                 y_sim_old = self.accepted_y_sim_bds.value()[index]
-                ## Calculate acceptance probability:
+                # Calculate acceptance probability:
                 numerator = 0.0
                 denominator = 0.0
                 for ind in range(self.n_samples_per_param):
diff --git a/abcpy/probabilisticmodels.py b/abcpy/probabilisticmodels.py
index 93eb98dc..ddafda15 100644
--- a/abcpy/probabilisticmodels.py
+++ b/abcpy/probabilisticmodels.py
@@ -807,7 +807,7 @@ def forward_simulate(self, input_values, k, rng=np.random.RandomState(), mpi_com
     def pdf(self, input_values, x):
         # Mathematically, the expression for the pdf of a hyperparameter should be: if(x==self.fixed_parameters) return
         # 1; else return 0; However, since the pdf is called recursively for the whole model structure, and pdfs
-        # multiply, this would mean that all pdfs become 0. Setting the return value to 1 ensures proper calulation of
+        # multiply, this would mean that all pdfs become 0. Setting the return value to 1 ensures proper computation of
         # the overall pdf.
         return 1.
 
diff --git a/abcpy/statistics.py b/abcpy/statistics.py
index 7d4a7179..88e6000c 100644
--- a/abcpy/statistics.py
+++ b/abcpy/statistics.py
@@ -84,7 +84,7 @@ def _polynomial_expansion(self, summary_statistics):
 
         """
 
-        # Check summary_statistics is a np.ndarry
+        # Check summary_statistics is a np.ndarray
         if not isinstance(summary_statistics, np.ndarray):
             raise TypeError('Summary statistics is not of allowed types')
         # Include the polynomial expansion

From ed7a8be27c8af0337757b4f10a105dbb7acd65b1 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Mon, 2 Nov 2020 19:47:33 +0100
Subject: [PATCH 078/106] Add ESS computation and storage in Journal when
 type==1; also add plot for ESS in Journal class

---
 abcpy/inferences.py   | 13 +++++++-
 abcpy/output.py       | 69 +++++++++++++++++++++++++++++++++++++++++++
 tests/output_tests.py | 27 +++++++++++++++++
 3 files changed, 108 insertions(+), 1 deletion(-)

diff --git a/abcpy/inferences.py b/abcpy/inferences.py
index 07b748b6..77d161cd 100644
--- a/abcpy/inferences.py
+++ b/abcpy/inferences.py
@@ -238,7 +238,8 @@ def sample(self, observations, n_samples, n_samples_per_param, epsilon, full_out
 
         self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters)
         journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
-        journal.add_weights(copy.deepcopy(np.ones((n_samples, 1))))
+        journal.add_weights(np.ones((n_samples, 1)))
+        journal.add_ESS_estimate(np.ones((n_samples, 1)))
         journal.add_distances(copy.deepcopy(distances))
         self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters)
         names_and_parameters = self._get_names_and_parameters()
@@ -509,6 +510,7 @@ def sample(self, observations, steps, epsilon_init, n_samples=10000, n_samples_p
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(distances))
                 journal.add_weights(copy.deepcopy(accepted_weights))
+                journal.add_ESS_estimate(accepted_weights)
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                                   accepted_weights=accepted_weights)
                 names_and_parameters = self._get_names_and_parameters()
@@ -911,6 +913,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=100,
             if (full_output == 1 and aStep <= steps - 1) or (full_output == 0 and aStep == steps - 1):
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_weights(copy.deepcopy(accepted_weights))
+                journal.add_ESS_estimate(accepted_weights)
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                                   accepted_weights=accepted_weights)
                 names_and_parameters = self._get_names_and_parameters()
@@ -1313,6 +1316,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                     self.logger.info('Saving after resampling')
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                     journal.add_weights(copy.deepcopy(accepted_weights))
+                    journal.add_ESS_estimate(accepted_weights)
                     journal.add_distances(copy.deepcopy(distances))
                     names_and_parameters = self._get_names_and_parameters()
                     journal.add_user_parameters(names_and_parameters)
@@ -1338,6 +1342,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
                     # Saving intermediate configuration to output journal.
                     journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                     journal.add_weights(copy.deepcopy(accepted_weights))
+                    journal.add_ESS_estimate(accepted_weights)
                     journal.add_distances(copy.deepcopy(distances))
                     names_and_parameters = self._get_names_and_parameters()
                     journal.add_user_parameters(names_and_parameters)
@@ -1348,6 +1353,7 @@ def sample(self, observations, steps, epsilon, n_samples=10000, n_samples_per_pa
         if (full_output == 0) or (full_output == 1 and broken_preemptively and aStep <= steps - 1):
             journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
             journal.add_weights(copy.deepcopy(accepted_weights))
+            journal.add_ESS_estimate(accepted_weights)
             journal.add_distances(copy.deepcopy(distances))
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                               accepted_weights=accepted_weights)
@@ -1753,6 +1759,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(distances))
                 journal.add_weights(copy.deepcopy(accepted_weights))
+                journal.add_ESS_estimate(accepted_weights)
                 journal.add_opt_values(accepted_cov_mats)
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                                   accepted_weights=accepted_weights)
@@ -1775,6 +1782,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch
             journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
             journal.add_distances(copy.deepcopy(distances))
             journal.add_weights(copy.deepcopy(accepted_weights))
+            journal.add_ESS_estimate(accepted_weights)
             journal.add_opt_values(accepted_cov_mats)
             self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters,
                                                               accepted_weights=accepted_weights)
@@ -2150,6 +2158,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, al
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(accepted_dist))
                 journal.add_weights(accepted_weights)
+                journal.add_ESS_estimate(accepted_weights)
                 self.accepted_parameters_manager.update_broadcast(self.backend, accepted_weights=accepted_weights,
                                                                   accepted_parameters=accepted_parameters)
                 names_and_parameters = self._get_names_and_parameters()
@@ -2511,6 +2520,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, al
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(accepted_dist))
                 journal.add_weights(copy.deepcopy(accepted_weights))
+                journal.add_ESS_estimate(accepted_weights)
                 self.accepted_parameters_manager.update_broadcast(self.backend,
                                                                   accepted_parameters=accepted_parameters,
                                                                   accepted_weights=accepted_weights)
@@ -2883,6 +2893,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep
                 journal.add_accepted_parameters(copy.deepcopy(accepted_parameters))
                 journal.add_distances(copy.deepcopy(distances))
                 journal.add_weights(copy.deepcopy(accepted_weights))
+                journal.add_ESS_estimate(accepted_weights)
                 journal.add_opt_values(copy.deepcopy(accepted_y_sim))
 
                 names_and_parameters = self._get_names_and_parameters()
diff --git a/abcpy/output.py b/abcpy/output.py
index fdda266c..7823fb98 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -38,6 +38,7 @@ def __init__(self, type):
         self.accepted_parameters = []
         self.names_and_parameters = []
         self.weights = []
+        self.ESS = []
         self.distances = []
         self.opt_values = []
         self.configuration = {}
@@ -158,6 +159,29 @@ def add_opt_values(self, opt_values):
         if self._type == 1:
             self.opt_values.append(opt_values)
 
+    def add_ESS_estimate(self, weights):
+        """
+        Computes and saves Effective Sample Size (ESS) estimate starting from provided weights; ESS is estimated as sum
+        the inverse of sum of squared normalized weights. The provided weights are normalized before computing ESS.
+        If type==0, old ESS estimate gets overwritten.
+
+        Parameters
+        ----------
+        weights: numpy.array
+            vector containing n weigths
+        """
+
+        # normalize weights:
+        normalized_weights = weights / np.sum(weights)
+
+        ESS = 1 / sum(pow(normalized_weights, 2))
+
+        if self._type == 0:
+            self.ESS = [ESS]
+
+        if self._type == 1:
+            self.ESS.append(ESS)
+
     def save(self, filename):
         """
         Stores the journal to disk.
@@ -256,6 +280,22 @@ def get_distances(self, iteration=None):
         else:
             return self.distances[iteration]
 
+    def get_ESS_estimates(self, iteration=None):
+        """
+        Returns the estimate of Effective Sample Size (ESS) from a sampling scheme.
+
+        For intermediate results, pass the iteration.
+
+        Parameters
+        ----------
+        iteration: int
+            specify the iteration for which to return ESS
+        """
+        if iteration is None:
+            iteration = -1
+
+        return self.ESS[iteration]
+
     def posterior_mean(self, iteration=None):
         """
         Computes posterior mean from the samples drawn from posterior distribution
@@ -728,3 +768,32 @@ def double_marginals_plot(data, meanpost, names, **kwargs):
             plt.savefig(path_to_save, bbox_inches="tight")
 
         return fig, axes
+
+    def plot_ESS(self):
+        """
+        Produces a plot showing the evolution of the estimated ESS (from sample weights) across iterations; it also
+        shows as a baseline the maximum possible ESS which can be achieved, corresponding to the case of independent
+        samples, which is equal to the total number of samples.
+
+        Returns
+        -------
+        list
+            a list containing the matplotlib "fig, ax" objects defining the plot. Can be useful for further
+            modifications.
+        """
+
+        if self._type == 0:
+            raise RuntimeError("ESS plot is available only if the journal was created with full_output=1; otherwise, "
+                               "ESS is saved only for the last iteration.")
+
+        fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))
+
+        ax.scatter(np.arange(len(self.ESS)) + 1, self.ESS, label="Estimated ESS")
+        ax.set_xlabel("Iteration")
+        ax.set_ylabel("ESS")
+        # put horizontal line at the largest value ESS can get:
+        ax.axhline(len(self.weights[-1]), label="Max theoretical value", ls="dashed")
+        ax.legend()
+        ax.set_xticks(np.arange(len(self.ESS)) + 1)
+
+        return fig, ax
diff --git a/tests/output_tests.py b/tests/output_tests.py
index c9a10fe1..48ae5d1f 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -76,6 +76,33 @@ def test_load_and_save(self):
         # np.testing.assert_equal(journal.parameters, new_journal.parameters)
         np.testing.assert_equal(journal.weights, new_journal.weights)
 
+    def test_ESS(self):
+        weights_identical = np.ones(100)
+        weights = np.arange(100)
+        journal = Journal(1)
+        journal.add_weights(weights_identical)
+        journal.add_weights(weights)
+        journal.add_ESS_estimate(weights=weights_identical)
+        journal.add_ESS_estimate(weights=weights)
+        self.assertEqual(len(journal.ESS), 2)
+        self.assertAlmostEqual(journal.get_ESS_estimates(), 74.62311557788945)
+        self.assertAlmostEqual(journal.get_ESS_estimates(0), 100)
+
+    def test_plot_ESS(self):
+        weights_identical = np.ones(100)
+        weights_1 = np.arange(100)
+        weights_2 = np.arange(100, 200)
+        journal = Journal(1)
+        journal.add_weights(weights_identical)
+        journal.add_ESS_estimate(weights=weights_identical)
+        journal.add_weights(weights_1)
+        journal.add_ESS_estimate(weights=weights_1)
+        journal.add_weights(weights_2)
+        journal.add_ESS_estimate(weights=weights_2)
+        journal.plot_ESS()
+        journal_2 = Journal(0)
+        self.assertRaises(RuntimeError, journal_2.plot_ESS)
+
 
 if __name__ == '__main__':
     unittest.main()

From e0586f0590be3c921b0cfd05abe650a5ffd19e03 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 09:55:43 +0100
Subject: [PATCH 079/106] Add Wasserstein distance convergence plot in Journal
 class

---
 abcpy/output.py       | 62 ++++++++++++++++++++++++++++++++++++++++---
 abcpy/utils.py        | 32 ++++++++++++++++++++++
 tests/output_tests.py | 32 ++++++++++++++++++++++
 3 files changed, 122 insertions(+), 4 deletions(-)

diff --git a/abcpy/output.py b/abcpy/output.py
index 7823fb98..96ee31c8 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -5,6 +5,8 @@
 import numpy as np
 from scipy.stats import gaussian_kde
 
+from abcpy.utils import wass_dist
+
 
 class Journal:
     """The journal holds information created by the run of inference schemes.
@@ -455,8 +457,8 @@ def plot_posterior_distr(self, parameters_to_show=None, ranges_parameters=None,
 
         Returns
         -------
-        list
-            a list containing the matplotlib "fig, axes" objects defining the plot. Can be useful for further
+        tuple
+            a tuple containing the matplotlib "fig, axes" objects defining the plot. Can be useful for further
             modifications.
         """
 
@@ -777,8 +779,8 @@ def plot_ESS(self):
 
         Returns
         -------
-        list
-            a list containing the matplotlib "fig, ax" objects defining the plot. Can be useful for further
+        tuple
+            a tuple containing the matplotlib "fig, ax" objects defining the plot. Can be useful for further
             modifications.
         """
 
@@ -797,3 +799,55 @@ def plot_ESS(self):
         ax.set_xticks(np.arange(len(self.ESS)) + 1)
 
         return fig, ax
+
+    def Wass_convergence_plot(self):
+        """
+        Computes the Wasserstein distance between the empirical distribution at subsequent iterations to see whether
+        the approximation of the posterior is converging. Then, it produces a plot displaying that. The approximation of
+        the posterior is converging if the Wass distance between subsequent iterations decreases with iteration and gets
+        close to 0, as that means there is no evolution of the posterior samples. The Wasserstein distance is estimated
+        using the POT library).
+
+        This method only works when the Journal stores results from all the iterations (ie it was generated with
+        full_output=1).
+
+        Returns
+        -------
+        tuple
+            a tuple containing the matplotlib "fig, ax" objects defining the plot and the list of the computed
+            Wasserstein distances. "fig" and "ax" can be useful for further modifying the plot.
+        """
+        if self._type == 0:
+            raise RuntimeError("Wasserstein distance convergence test is available only if the journal was created with"
+                               " full_output=1; in fact, this works by comparing the saved empirical distribution at "
+                               "different iterations, and the latter is saved only if full_output=1.")
+
+        if len(self.weights) == 1:
+            raise RuntimeError("Only a set of posterior samples has been saved, corresponding to either running a "
+                               "sequential algorithm for one iteration only or to using non-sequential algorithms (as"
+                               "RejectionABC). Wasserstein distance convergence test requires at least samples from at "
+                               "least 2 iterations.")
+
+        wass_dist_lists = [None] * (len(self.weights) - 1)
+
+        for i in range(len(self.weights) - 1):
+            params_1 = self.get_accepted_parameters(i)
+            params_2 = self.get_accepted_parameters(i + 1)
+            if len(params_1.shape) == 1:  # we assume that the dimension of parameters is 1
+                params_1 = params_1.reshape(-1, 1)
+            if len(params_2.shape) == 1:  # we assume that the dimension of parameters is 1
+                params_2 = params_2.reshape(-1, 1)
+            wass_dist_lists[i] = wass_dist(post_samples_1=params_1, post_samples_2=params_2,
+                                           weights_post_1=self.get_weights(i),
+                                           weights_post_2=self.get_weights(i + 1))[1].get('cost')
+
+        fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))
+        ax.scatter(np.arange(len(self.weights) - 1) + 1, wass_dist_lists,
+                   label="Estimated Wass. distance\nbetween iteration i and i+1")
+        ax.set_xlabel("Iteration")
+        ax.set_ylabel("Wasserstein distance")
+        ax.legend()
+        # put horizontal line at the largest value ESS can get:
+        ax.set_xticks(np.arange(len(self.weights) - 1) + 1)
+
+        return fig, ax, wass_dist_lists
diff --git a/abcpy/utils.py b/abcpy/utils.py
index 800c121c..041cdbc5 100644
--- a/abcpy/utils.py
+++ b/abcpy/utils.py
@@ -1,5 +1,8 @@
 from functools import wraps
 
+import numpy as np
+import ot
+
 
 def cached(func):
     cache = {}
@@ -11,3 +14,32 @@ def wrapped(x):
         return cache[x]
 
     return wrapped
+
+
+def wass_dist(post_samples_1, post_samples_2, weights_post_1=None, weights_post_2=None):
+    """Computes the Wasserstein 2 distance.
+
+    post_samples_1 and post_post_samples_2 are 2 dimensional arrays: first dim is the number of samples, 2nd dim is the
+    number of coordinates in the each sample.
+
+    We allow to give weights to the posterior distribution. Leave weights_post_1 and weights_post_2 to None if your
+    samples do not have weights. """
+
+    n = post_samples_1.shape[0]
+
+    if weights_post_1 is None:
+        a = np.ones((n,)) / n
+    else:
+        a = weights_post_1 / np.sum(weights_post_1)
+    if weights_post_2 is None:
+        b = np.ones((n,)) / n
+    else:
+        b = weights_post_2 / np.sum(weights_post_2)
+
+    # loss matrix
+    M = ot.dist(x1=post_samples_1, x2=post_samples_2)  # this returns squared distance!
+    G0 = ot.emd(a, b, M, log=True)
+
+    # print('EMD cost:', G0[1].get('cost'))
+
+    return G0
diff --git a/tests/output_tests.py b/tests/output_tests.py
index 48ae5d1f..120dd38a 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -103,6 +103,38 @@ def test_plot_ESS(self):
         journal_2 = Journal(0)
         self.assertRaises(RuntimeError, journal_2.plot_ESS)
 
+    def test_plot_wass_dist(self):
+        rng = np.random.RandomState(1)
+        weights_identical = np.ones(100)
+        params_0 = rng.randn(100)
+        weights_1 = np.arange(100)
+        params_1 = rng.randn(100)
+        weights_2 = np.arange(100, 200)
+        params_2 = rng.randn(100)
+        weights_3 = np.arange(200, 300)
+        params_3 = rng.randn(100)
+        weights_4 = np.arange(300, 400)
+        params_4 = rng.randn(100)
+        journal = Journal(1)
+        journal.add_weights(weights_identical)
+        journal.add_accepted_parameters(params_0)
+        journal.add_weights(weights_1)
+        journal.add_accepted_parameters(params_1)
+        journal.add_weights(weights_2)
+        journal.add_accepted_parameters(params_2)
+        journal.add_weights(weights_3)
+        journal.add_accepted_parameters(params_3)
+        journal.add_weights(weights_4)
+        journal.add_accepted_parameters(params_4)
+        fig, ax, wass_dist_lists = journal.Wass_convergence_plot()
+        self.assertAlmostEqual(wass_dist_lists[0], 0.05211720800690442)
+        # check the Errors
+        journal_2 = Journal(0)
+        self.assertRaises(RuntimeError, journal_2.Wass_convergence_plot)
+        journal_3 = Journal(1)
+        journal_3.add_weights(weights_identical)
+        self.assertRaises(RuntimeError, journal_2.Wass_convergence_plot)
+
 
 if __name__ == '__main__':
     unittest.main()

From b28d3b6107c6da2200cdd84a49462d690132c223 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 10:31:02 +0100
Subject: [PATCH 080/106] Add test for plot_posterior_distr

---
 tests/output_tests.py | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/tests/output_tests.py b/tests/output_tests.py
index 120dd38a..88ec690e 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -135,6 +135,32 @@ def test_plot_wass_dist(self):
         journal_3.add_weights(weights_identical)
         self.assertRaises(RuntimeError, journal_2.Wass_convergence_plot)
 
+    def test_plot_post_distr(self):
+        rng = np.random.RandomState(1)
+        weights_identical = np.ones((100, 1))
+        params = rng.randn(100, 2, 1, 1)
+        weights = np.arange(100).reshape(-1, 1)
+        journal = Journal(1)
+        journal.add_user_parameters([("par1", params[:, 0]), ("par2", params[:, 1])])
+        journal.add_user_parameters([("par1", params[:, 0]), ("par2", params[:, 1])])
+        journal.add_weights(weights=weights_identical)
+        journal.add_weights(weights=weights)
+        journal.plot_posterior_distr(single_marginals_only=True, iteration=0)
+        journal.plot_posterior_distr(double_marginals_only=True, show_samples=True,
+                                     true_parameter_values=[0.5, 0.3])
+        journal.plot_posterior_distr(contour_levels=10, ranges_parameters={"par1": [-1, 1]},
+                                     parameters_to_show=["par1"])
+
+        with self.assertRaises(KeyError):
+            journal.plot_posterior_distr(parameters_to_show=["par3"])
+        with self.assertRaises(RuntimeError):
+            journal.plot_posterior_distr(single_marginals_only=True, double_marginals_only=True)
+            journal.plot_posterior_distr(parameters_to_show=["par1"], double_marginals_only=True)
+            journal.plot_posterior_distr(parameters_to_show=["par1"], true_parameter_values=[0.5, 0.3])
+        with self.assertRaises(TypeError):
+            journal.plot_posterior_distr(ranges_parameters={"par1": [-1]})
+            journal.plot_posterior_distr(ranges_parameters={"par1": np.zeros(1)})
+
 
 if __name__ == '__main__':
     unittest.main()

From e3c8c191d2e58ffff2829717de9b0491d1890ff8 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 10:44:37 +0100
Subject: [PATCH 081/106] Add POT in requirements.txt

---
 requirements.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index d09c5a54..2ad58002 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,4 +8,5 @@ coverage
 mpi4py
 cloudpickle
 matplotlib
-tqdm
\ No newline at end of file
+tqdm
+pot
\ No newline at end of file

From 69a3850d964a0acab85bf555e931cb362a6c8933 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 10:45:27 +0100
Subject: [PATCH 082/106] Add test for errors in statisticslearning.py

---
 abcpy/statisticslearning.py       |  2 +-
 tests/statisticslearning_tests.py | 33 +++++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py
index 8102e7e7..36ef0914 100644
--- a/abcpy/statisticslearning.py
+++ b/abcpy/statisticslearning.py
@@ -251,7 +251,7 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe
         """
         # the sampling is performed by the init of the parent class
         super(Semiautomatic, self).__init__(model, statistics_calc, backend,
-                                            n_samples, n_samples_per_param, parameters=parameters,
+                                            n_samples, n_samples_per_param=n_samples_per_param, parameters=parameters,
                                             simulations=simulations, seed=seed)
 
         self.logger.info('Learning of the transformation...')
diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py
index c68b703f..d162e1ca 100644
--- a/tests/statisticslearning_tests.py
+++ b/tests/statisticslearning_tests.py
@@ -94,6 +94,39 @@ def test_transformation(self):
 
             self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])])
 
+    def test_errors(self):
+        with self.assertRaises(RuntimeError):
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, parameters=np.ones((100, 1)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)),
+                                                      parameters=np.zeros((99, 1)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2)))
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)),
+                                                      parameters_val=np.zeros((99, 1)))
+        with self.assertRaises(TypeError):
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1, parameters=[i for i in range(10)],
+                                                      simulations=[i for i in range(10)])
+            self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
+                                                      n_samples_per_param=1, seed=1,
+                                                      parameters_val=[i for i in range(10)],
+                                                      simulations_val=[i for i in range(10)])
+
 
 class ContrastiveDistanceLearningTests(unittest.TestCase):
     def setUp(self):

From 2b55c0e50579b5e95a1418b369cecfb6646c2650 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 11:01:40 +0100
Subject: [PATCH 083/106] Additional test for Statistics

---
 tests/statistics_tests.py | 32 ++++++++++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/tests/statistics_tests.py b/tests/statistics_tests.py
index 8c08dea4..334421d2 100644
--- a/tests/statistics_tests.py
+++ b/tests/statistics_tests.py
@@ -3,6 +3,7 @@
 import numpy as np
 
 from abcpy.statistics import Identity, LinearTransformation, NeuralEmbedding
+from abcpy.NN_utilities.networks import ScalerAndNet
 
 try:
     import torch
@@ -16,6 +17,7 @@
 class IdentityTests(unittest.TestCase):
     def setUp(self):
         self.stat_calc = Identity(degree=1, cross=0)
+        self.stat_calc_pipeline = Identity(degree=2, cross=False, previous_statistics=self.stat_calc)
 
     def test_statistics(self):
         self.assertRaises(TypeError, self.stat_calc.statistics, 3.4)
@@ -43,6 +45,10 @@ def test_polynomial_expansion(self):
         self.stat_calc = Identity(degree=2, cross=1)
         self.assertTrue((self.stat_calc.statistics(a) == np.array([[2, 4]])).all())
 
+    def test_pipeline(self):
+        vec1 = np.array([1, 2])
+        self.stat_calc_pipeline.statistics([vec1])
+
 
 class LinearTransformationTests(unittest.TestCase):
     def setUp(self):
@@ -82,13 +88,14 @@ class NeuralEmbeddingTests(unittest.TestCase):
     def setUp(self):
         if has_torch:
             self.net = createDefaultNN(2, 3)()
-
-    def test_statistics(self):
+            self.net_with_scaler = ScalerAndNet(self.net, None)
+            self.stat_calc = NeuralEmbedding(self.net)
+            self.stat_calc_with_scaler = NeuralEmbedding(self.net_with_scaler)
         if not has_torch:
             self.assertRaises(ImportError, NeuralEmbedding, None)
-        else:
-            self.stat_calc = NeuralEmbedding(self.net)
 
+    def test_statistics(self):
+        if has_torch:
             self.assertRaises(TypeError, self.stat_calc.statistics, 3.4)
             vec1 = np.array([1, 2])
             vec2 = np.array([1])
@@ -96,6 +103,23 @@ def test_statistics(self):
             self.assertTrue((self.stat_calc.statistics([vec1, vec1])).all())
             self.assertRaises(RuntimeError, self.stat_calc.statistics, [vec2])
 
+    def test_save_load(self):
+        if has_torch:
+            self.stat_calc.save_net("net.pth")
+            self.stat_calc_with_scaler.save_net("net.pth", path_to_scaler="scaler.pkl")
+            self.stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", input_size=2, output_size=3)
+            self.stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3))
+            self.stat_calc_loaded_with_scaler = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3),
+                                                                         path_to_scaler="scaler.pkl")
+
+            with self.assertRaises(RuntimeError):
+                self.stat_calc_with_scaler.save_net("net.pth")
+                self.stat_calc_loaded = NeuralEmbedding.fromFile("net.pth")
+                self.stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3),
+                                                                 input_size=1)
+                self.stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3),
+                                                                 hidden_sizes=[2, 3])
+
 
 if __name__ == '__main__':
     unittest.main()

From fab2e90436c2d850956c5b7eb3ce9c8a2f99a573 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 12:06:51 +0100
Subject: [PATCH 084/106] Explicitly close file with cloudpickle

---
 abcpy/statistics.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/abcpy/statistics.py b/abcpy/statistics.py
index 88e6000c..fdde773e 100644
--- a/abcpy/statistics.py
+++ b/abcpy/statistics.py
@@ -342,7 +342,9 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, path_to_scaler=Non
                                                                    hidden_sizes=hidden_sizes))
 
         if path_to_scaler is not None:
-            scaler = cloudpickle.load(open(path_to_scaler, 'rb'))
+            f = open(path_to_scaler, 'rb')
+            scaler = cloudpickle.load(f)
+            f.close()
             net = ScalerAndNet(net, scaler)
 
         statistic_object = cls(net, previous_statistics=previous_statistics)
@@ -370,7 +372,9 @@ def save_net(self, path_to_net_state_dict, path_to_scaler=None):
 
         if hasattr(self.net, "scaler"):
             save_net(path_to_net_state_dict, self.net.net)
-            cloudpickle.dump(self.net.scaler, open(path_to_scaler, 'wb'))
+            f = open(path_to_scaler, 'wb')
+            cloudpickle.dump(self.net.scaler, f)
+            f.close()
         else:
             save_net(path_to_net_state_dict, self.net)
 

From 4c706bb36e0428fc584445ba322ec36c196b0a0a Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 16:53:24 +0100
Subject: [PATCH 085/106] Fix issues with importing modules in sphinx

---
 abcpy/backends/mpimanager.py | 5 ++---
 doc/source/conf.py           | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/abcpy/backends/mpimanager.py b/abcpy/backends/mpimanager.py
index ad4a91cf..58f9ec94 100644
--- a/abcpy/backends/mpimanager.py
+++ b/abcpy/backends/mpimanager.py
@@ -1,6 +1,6 @@
 from mpi4py import MPI
 
-__mpimanager = None
+mpimanager = None
 
 
 class MPIManager(object):
@@ -123,8 +123,7 @@ def get_scheduler_communicator(self):
 def get_mpi_manager():
     ''' Return the instance of mpimanager
     Creates one with default parameters is not already existing '''
-    global mpimanager
-    if mpimanager == None:
+    if mpimanager is None:
         create_mpi_manager([0], 1)
     return mpimanager
 
diff --git a/doc/source/conf.py b/doc/source/conf.py
index fb895aa4..02b18b0b 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -25,7 +25,7 @@ class Mock(MagicMock):
     def __getattr__(cls, name):
             return MagicMock()
 
-MOCK_MODULES = ['numpy', 'pandas', 'glmnet', 'mpi4py', 'scipy', 'scipy.stats', 'scipy.special', 'scipy.optimize', 'sklearn', 'sklearn.covariance', 'findspark', 'coverage', 'numpy.random', 'matplotlib', 'matplotlib.pyplot', 'torch']
+MOCK_MODULES = ['numpy', 'pandas', 'glmnet', 'scipy', 'scipy.stats', 'scipy.special', 'scipy.optimize', 'sklearn', 'sklearn.covariance', 'findspark', 'coverage', 'numpy.random', 'matplotlib', 'matplotlib.pyplot', 'torch', 'ot']
 sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
 
 # If extensions (or modules to document with autodoc) are in another directory,

From 85e8bfed72cc3860832840c38532788a68387209 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Tue, 3 Nov 2020 17:05:47 +0100
Subject: [PATCH 086/106] Improve the Wass distance convergence check;
 specifically, fix using weights with two dimensions, and return the correct
 wass distance instead of squared one.

---
 abcpy/output.py       | 41 +++++++++++++++++++++++-----
 abcpy/utils.py        | 63 ++++++++++++++++++++++++++++++-------------
 tests/output_tests.py | 30 ++++++++++++---------
 3 files changed, 96 insertions(+), 38 deletions(-)

diff --git a/abcpy/output.py b/abcpy/output.py
index 96ee31c8..e591075b 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -99,7 +99,9 @@ def add_user_parameters(self, names_and_params):
 
     def add_accepted_parameters(self, accepted_parameters):
         """
-        Saves provided weights by appending them to the journal. If type==0, old weights get overwritten.
+        FIX THIS!
+        Saves provided accepted parameters by appending them to the journal. If type==0, old accepted parameters get
+        overwritten.
 
         Parameters
         ----------
@@ -176,7 +178,7 @@ def add_ESS_estimate(self, weights):
         # normalize weights:
         normalized_weights = weights / np.sum(weights)
 
-        ESS = 1 / sum(pow(normalized_weights, 2))
+        ESS = 1 / sum(sum(pow(normalized_weights, 2)))
 
         if self._type == 0:
             self.ESS = [ESS]
@@ -800,7 +802,7 @@ def plot_ESS(self):
 
         return fig, ax
 
-    def Wass_convergence_plot(self):
+    def Wass_convergence_plot(self, num_iter_max=1e8, **kwargs):
         """
         Computes the Wasserstein distance between the empirical distribution at subsequent iterations to see whether
         the approximation of the posterior is converging. Then, it produces a plot displaying that. The approximation of
@@ -809,7 +811,15 @@ def Wass_convergence_plot(self):
         using the POT library).
 
         This method only works when the Journal stores results from all the iterations (ie it was generated with
-        full_output=1).
+        full_output=1). Moreover, this only works when all the parameters in the model are univariate.
+
+        Parameters
+        ----------
+        num_iter_max : integer, optional
+            The maximum number of iterations in the linear programming algorithm to estimate the Wasserstein distance.
+            Default to 1e8.
+        kwargs
+            Additional arguments passed to the wass_dist calculation function.
 
         Returns
         -------
@@ -827,19 +837,36 @@ def Wass_convergence_plot(self):
                                "sequential algorithm for one iteration only or to using non-sequential algorithms (as"
                                "RejectionABC). Wasserstein distance convergence test requires at least samples from at "
                                "least 2 iterations.")
+        if self.get_accepted_parameters().dtype == "object":
+            raise RuntimeError("This error was probably raised due to the parameters in your model having different "
+                               "dimenions (and specifically not being univariate). For now, Wasserstein distance"
+                               " convergence test is available only if the different parameters have the same "
+                               "dimension.")
 
         wass_dist_lists = [None] * (len(self.weights) - 1)
 
         for i in range(len(self.weights) - 1):
+            print(i)
             params_1 = self.get_accepted_parameters(i)
             params_2 = self.get_accepted_parameters(i + 1)
+            weights_1 = self.get_weights(i)
+            weights_2 = self.get_weights(i + 1)
             if len(params_1.shape) == 1:  # we assume that the dimension of parameters is 1
                 params_1 = params_1.reshape(-1, 1)
+            else:
+                params_1 = params_1.reshape(params_1.shape[0], -1)
             if len(params_2.shape) == 1:  # we assume that the dimension of parameters is 1
                 params_2 = params_2.reshape(-1, 1)
-            wass_dist_lists[i] = wass_dist(post_samples_1=params_1, post_samples_2=params_2,
-                                           weights_post_1=self.get_weights(i),
-                                           weights_post_2=self.get_weights(i + 1))[1].get('cost')
+            else:
+                params_2 = params_2.reshape(params_2.shape[0], -1)
+
+            if len(weights_1.shape) == 2:  # it can be that the weights have shape (-1,1); reshape therefore
+                weights_1 = weights_1.reshape(-1)
+            if len(weights_2.shape) == 2:  # it can be that the weights have shape (-1,1); reshape therefore
+                weights_2 = weights_2.reshape(-1)
+
+            wass_dist_lists[i] = wass_dist(samples_1=params_1, samples_2=params_2, weights_1=weights_1,
+                                           weights_2=weights_2, num_iter_max=num_iter_max, **kwargs)
 
         fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))
         ax.scatter(np.arange(len(self.weights) - 1) + 1, wass_dist_lists,
diff --git a/abcpy/utils.py b/abcpy/utils.py
index 041cdbc5..0e128b98 100644
--- a/abcpy/utils.py
+++ b/abcpy/utils.py
@@ -16,30 +16,57 @@ def wrapped(x):
     return wrapped
 
 
-def wass_dist(post_samples_1, post_samples_2, weights_post_1=None, weights_post_2=None):
-    """Computes the Wasserstein 2 distance.
+def wass_dist(samples_1, samples_2, weights_1=None, weights_2=None, num_iter_max=100000, **kwargs):
+    """
+    Computes the Wasserstein 2 distance between two empirical distributions with weights. This uses the POT library to 
+    estimate Wasserstein distance. The Wasserstein distance computation can take long if the number of samples in the 
+    two datasets is large (cost of the computation scales in fact quadratically with the number of samples).
 
-    post_samples_1 and post_post_samples_2 are 2 dimensional arrays: first dim is the number of samples, 2nd dim is the
-    number of coordinates in the each sample.
+    Parameters
+    ----------
+    samples_1 : np.ndarray
+         Samples defining the first empirical distribution, with shape (nxd), n being the number of samples in the
+         first empirical distribution and d the dimension of the random variable.
+    samples_2 : np.ndarray
+         Samples defining the second empirical distribution, with shape (mxd), m being the number of samples in the
+         second empirical distribution and d the dimension of the random variable.
+    weights_1 : np.ndarray, optional
+         Weights defining the first empirical distribution, with shape (n), n being the number of samples in the
+         first empirical distribution. Weights are normalized internally to the function. If not provided, they are
+         assumed to be identical for all samples.
+    weights_2 : np.ndarray, optional
+         Weights defining the second empirical distribution, with shape (m), m being the number of samples in the
+         second empirical distribution. Weights are normalized internally to the function. If not provided, they are
+         assumed to be identical for all samples.
+    num_iter_max : integer, optional
+        The maximum number of iterations in the linear programming algorithm to estimate the Wasserstein distance. 
+        Default to 100000. 
+    kwargs 
+        Additional arguments passed to ot.emd2
 
-    We allow to give weights to the posterior distribution. Leave weights_post_1 and weights_post_2 to None if your
-    samples do not have weights. """
+    Returns
+    -------
+    float
+        The estimated 2-Wasserstein distance.
+    """
+    n = samples_1.shape[0]
+    m = samples_2.shape[0]
 
-    n = post_samples_1.shape[0]
-
-    if weights_post_1 is None:
+    if weights_1 is None:
         a = np.ones((n,)) / n
     else:
-        a = weights_post_1 / np.sum(weights_post_1)
-    if weights_post_2 is None:
-        b = np.ones((n,)) / n
+        if len(weights_1) != n:
+            raise RuntimeError("Number of weights and number of samples need to be the same.")
+        a = weights_1 / np.sum(weights_1)
+    if weights_2 is None:
+        b = np.ones((m,)) / m
     else:
-        b = weights_post_2 / np.sum(weights_post_2)
+        if len(weights_2) != m:
+            raise RuntimeError("Number of weights and number of samples need to be the same.")
+        b = weights_2 / np.sum(weights_2)
 
     # loss matrix
-    M = ot.dist(x1=post_samples_1, x2=post_samples_2)  # this returns squared distance!
-    G0 = ot.emd(a, b, M, log=True)
-
-    # print('EMD cost:', G0[1].get('cost'))
+    M = ot.dist(x1=samples_1, x2=samples_2)  # this returns squared distance!
+    cost = ot.emd2(a, b, M, numItermax=num_iter_max, **kwargs)
 
-    return G0
+    return np.sqrt(cost)
diff --git a/tests/output_tests.py b/tests/output_tests.py
index 88ec690e..81662448 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -77,8 +77,8 @@ def test_load_and_save(self):
         np.testing.assert_equal(journal.weights, new_journal.weights)
 
     def test_ESS(self):
-        weights_identical = np.ones(100)
-        weights = np.arange(100)
+        weights_identical = np.ones((100, 1))
+        weights = np.arange(100).reshape(-1, 1)
         journal = Journal(1)
         journal.add_weights(weights_identical)
         journal.add_weights(weights)
@@ -89,9 +89,9 @@ def test_ESS(self):
         self.assertAlmostEqual(journal.get_ESS_estimates(0), 100)
 
     def test_plot_ESS(self):
-        weights_identical = np.ones(100)
-        weights_1 = np.arange(100)
-        weights_2 = np.arange(100, 200)
+        weights_identical = np.ones((100, 1))
+        weights_1 = np.arange(100).reshape(-1, 1)
+        weights_2 = np.arange(100, 200).reshape(-1, 1)
         journal = Journal(1)
         journal.add_weights(weights_identical)
         journal.add_ESS_estimate(weights=weights_identical)
@@ -105,16 +105,16 @@ def test_plot_ESS(self):
 
     def test_plot_wass_dist(self):
         rng = np.random.RandomState(1)
-        weights_identical = np.ones(100)
-        params_0 = rng.randn(100)
+        weights_identical = np.ones((100, 1))
+        params_0 = rng.randn(100).reshape(-1, 1)
         weights_1 = np.arange(100)
-        params_1 = rng.randn(100)
+        params_1 = rng.randn(100).reshape(-1, 1, 1)
         weights_2 = np.arange(100, 200)
-        params_2 = rng.randn(100)
+        params_2 = rng.randn(100).reshape(-1, 1)
         weights_3 = np.arange(200, 300)
-        params_3 = rng.randn(100)
+        params_3 = rng.randn(100).reshape(-1, 1)
         weights_4 = np.arange(300, 400)
-        params_4 = rng.randn(100)
+        params_4 = rng.randn(100).reshape(-1, 1)
         journal = Journal(1)
         journal.add_weights(weights_identical)
         journal.add_accepted_parameters(params_0)
@@ -127,13 +127,17 @@ def test_plot_wass_dist(self):
         journal.add_weights(weights_4)
         journal.add_accepted_parameters(params_4)
         fig, ax, wass_dist_lists = journal.Wass_convergence_plot()
-        self.assertAlmostEqual(wass_dist_lists[0], 0.05211720800690442)
+        self.assertAlmostEqual(wass_dist_lists[0], 0.22829193592175878)
         # check the Errors
         journal_2 = Journal(0)
         self.assertRaises(RuntimeError, journal_2.Wass_convergence_plot)
         journal_3 = Journal(1)
         journal_3.add_weights(weights_identical)
-        self.assertRaises(RuntimeError, journal_2.Wass_convergence_plot)
+        self.assertRaises(RuntimeError, journal_3.Wass_convergence_plot)
+        journal_4 = Journal(1)
+        journal_4.add_accepted_parameters(np.array([np.array([1]), np.array([1, 2])]))
+        print(len(journal_4.accepted_parameters))
+        self.assertRaises(RuntimeError, journal_4.Wass_convergence_plot)
 
     def test_plot_post_distr(self):
         rng = np.random.RandomState(1)

From 2d97f60f7ce4ddc0526aab8dbfefefd13c832363 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 4 Nov 2020 16:09:17 +0100
Subject: [PATCH 087/106] Fix python scripts in docs

---
 doc/source/getting_started.rst    | 52 +++++++++++++++----------------
 doc/source/parallelization.rst    |  4 +--
 doc/source/postanalysis.rst       | 22 ++++++-------
 doc/source/user_customization.rst | 38 +++++++++++-----------
 4 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst
index f397b5a4..3c27dbfb 100644
--- a/doc/source/getting_started.rst
+++ b/doc/source/getting_started.rst
@@ -16,7 +16,7 @@ measurement of heights and the probabilistic model would be Gaussian.
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 74-75, 80-82
+    :lines: 86-98, 103-105
     :dedent: 4
 
 The Gaussian or Normal model has two parameters: the mean, denoted by :math:`\mu`, and the standard deviation, denoted
@@ -43,7 +43,7 @@ follows:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 76-82
+    :lines: 99-105
     :dedent: 4
 
 We have defined the parameter :math:`\mu` and :math:`\sigma` of the Gaussian model as random variables and assigned
@@ -68,7 +68,7 @@ first define a way to extract *summary statistics* from the dataset.
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 84-86
+    :lines: 107-109
     :dedent: 4
 
 Next we define the discrepancy measure between the datasets, by defining a distance function (LogReg distance is chosen
@@ -79,7 +79,7 @@ the datasets, and then compute the distance between the two statistics.
  
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 88-90
+    :lines: 111-113
     :dedent: 4
 
 Algorithms in ABCpy often require a perturbation kernel, a tool to explore the parameter space. Here, we use the default
@@ -89,7 +89,7 @@ discrete. For a more involved example, please consult `Composite Perturbation Ke
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 92-94
+    :lines: 115-117
     :dedent: 4
 
 Finally, we need to specify a backend that determines the parallelization framework to use. The example code here uses
@@ -99,7 +99,7 @@ available in ABCpy, please consult :ref:`Using Parallelization Backends <paralle
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 96-99
+    :lines: 119-122
     :dedent: 4
 
 In this example, we choose PMCABC algorithm (inference scheme) to draw posterior samples of the parameters. Therefore,
@@ -108,7 +108,7 @@ function, backend object, perturbation kernel and a seed for the random number g
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 101-103
+    :lines: 124-126
     :dedent: 4
 
 Finally, we can parametrize the sampler and start sampling from the posterior distribution of the parameters given the
@@ -116,7 +116,7 @@ observed dataset:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 105-109
+    :lines: 128-131
     :dedent: 4
 
 The above inference scheme gives us samples from the posterior distribution of the parameter of interest *height*
@@ -151,7 +151,7 @@ of the students are:
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 6
+    :lines: 29-42
     :dedent: 4
 
 which depend on several variables: if there were bias, the average size of the
@@ -171,7 +171,7 @@ in the following way:
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 9-10, 13, 16, 19
+    :lines: 46-47,50,53,56
     :dedent: 4
 
 So, each student will receive some grade without additional effects which is
@@ -182,7 +182,7 @@ the final grade of the students now can be written as:
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 22
+    :lines: 59
     :dedent: 4
 
 Notice here we created a new random variable `final_grade`, by subtracting the random variables `class_size` multiplied
@@ -213,7 +213,7 @@ Whether a student gets a scholarship depends on the number of teachers in the sc
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 25, 28, 31
+    :lines: 62-75, 78, 81
     :dedent: 4
 
 With this we now have two *root* ProbabilisicModels (random variables), namely :code:`final_grade` and
@@ -230,14 +230,14 @@ different observed datasets.
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 33-41
+    :lines: 83-91
     :dedent: 4
 
 Using these two distance functions with the final code look as follows:
 
 .. literalinclude:: ../../examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py
     :language: python
-    :lines: 43-64
+    :lines: 93-115
     :dedent: 4
 
 Observe that the lists given to the sampler and the sampling method now contain two entries. These correspond to the two
@@ -258,7 +258,7 @@ parameters we would like to perturb using a multivariate Student's-T kernel. Thi
 
 .. literalinclude:: ../../examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
     :language: python
-    :lines: 46-49
+    :lines: 96-99
     :dedent: 4
 
 We have now defined how each set of parameters is perturbed on its own. The sampler object, however, needs to be
@@ -268,7 +268,7 @@ It just needs to be provided with all the relevant kernels:
 
 .. literalinclude:: ../../examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py
     :language: python
-    :lines: 51-53
+    :lines: 101-103
     :dedent: 4
 
 This is all that needs to be changed. The rest of the implementation works the exact same as in the previous example. If
@@ -315,14 +315,14 @@ root models.
 
 .. literalinclude:: ../../examples/approx_lhd/pmc_hierarchical_models.py
     :language: python
-    :lines: 33-41
+    :lines: 78-86
     :dedent: 4
 
 We then parametrize the sampler and sample from the posterior distribution. 
 
 .. literalinclude:: ../../examples/approx_lhd/pmc_hierarchical_models.py
     :language: python
-    :lines: 52-64
+    :lines: 97-103
     :dedent: 4 
 
 Observe that the lists given to the sampler and the sampling method now contain two entries. These correspond to the two
@@ -373,7 +373,7 @@ The original summary statistics were defined as follows:
 
 .. literalinclude:: ../../examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
     :language: python
-    :lines: 21-23
+    :lines: 52-54
     :dedent: 4
 
 Then we can learn the optimized summary statistics from the above list of summary statistics using the semi-automatic
@@ -381,14 +381,14 @@ summary selection procedure as follows:
 
 .. literalinclude:: ../../examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
     :language: python
-    :lines: 25-31
+    :lines: 56-62
     :dedent: 4
 
 We remark that the minimal amount of coding needed for using the neural network based regression does not change at all:
 
 .. literalinclude:: ../../examples/statisticslearning/pmcabc_gaussian_statistics_learning.py
     :language: python
-    :lines: 34-42
+    :lines: 64-72
     :dedent: 4
 
 And similarly for the other two approaches.
@@ -407,28 +407,28 @@ most suitable one for the observed dataset `y_obs`.
 
 .. literalinclude:: ../../examples/modelselection/randomforest_modelselections.py
     :language: python
-    :lines: 7-19
+    :lines: 11-23
     :dedent: 4
 
 We first need to initiate the Model Selection scheme, for which we need to define the summary statistics and backend:
 
 .. literalinclude:: ../../examples/modelselection/randomforest_modelselections.py
     :language: python
-    :lines: 21-30
+    :lines: 25-34
     :dedent: 4
 
 Now we can choose the most suitable model for the observed dataset `y_obs`,
 
 .. literalinclude:: ../../examples/modelselection/randomforest_modelselections.py
     :language: python
-    :lines: 32-33
+    :lines: 36-37
     :dedent: 4
 
 or compute posterior probability of each of the models given the observed dataset.
 
 .. literalinclude:: ../../examples/modelselection/randomforest_modelselections.py
    :language: python
-   :lines: 35-36
+   :lines: 39-40
    :dedent: 4
 
 
@@ -441,5 +441,5 @@ setting it to info mode at the beginning of the file.
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
    :language: python
-   :lines: 1, 8
+   :lines: 1, 85
    :dedent: 0
diff --git a/doc/source/parallelization.rst b/doc/source/parallelization.rst
index c433e37d..3d5b588a 100644
--- a/doc/source/parallelization.rst
+++ b/doc/source/parallelization.rst
@@ -60,7 +60,7 @@ can be passed at the initialization of the backend as follows:
 
 .. literalinclude:: ../../examples/backends/mpi/mpi_model_inferences.py
     :language: python
-    :lines: 12-13
+    :lines: 13-14
     :dedent: 4
 
 Here each model is assigned a MPI communicator with 2 ranks. Clearly, the MPI
@@ -78,7 +78,7 @@ The `forward_simulation` function of the above model is as follows:
 
 .. literalinclude:: ../../examples/backends/mpi/mpi_model_inferences.py
     :language: python
-    :lines: 51-80
+    :lines: 52-81
     :dedent: 4
 
 Note that in order to run jobs in parallel you need to have MPI installed on the
diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst
index 91bbb1f8..903f5475 100644
--- a/doc/source/postanalysis.rst
+++ b/doc/source/postanalysis.rst
@@ -4,7 +4,7 @@
 ================
 
 The output of an inference scheme is a Journal
-(:py:class:`abcpy.output.Journal`) which holds all the necessary results and
+(:py:class:``abcpy.output.Journal``) which holds all the necessary results and
 convenient methods to do the post analysis.
 
 For example, one can easily access the sampled parameters and corresponding
@@ -12,17 +12,17 @@ weights using:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 60-61
+    :lines: 77-78
     :dedent: 4
 
-The output of `get_parameters()` is a Python dictionary. The keys for this dictionary are the names you specified for the parameters. The corresponding values are the marginal posterior samples of that parameter. Here is a short example of what you would specify, and what would be the output in the end:
+The output of ``get_parameters()`` is a Python dictionary. The keys for this dictionary are the names you specified for the parameters. The corresponding values are the marginal posterior samples of that parameter. Here is a short example of what you would specify, and what would be the output in the end:
 
 .. code-block:: python
 
     a = Normal([[1],[0.1]], name='parameter_1')
     b = MultivariateNormal([[1,1],[[0.1,0],[0,0.1]]], name='parameter_2')
 
-If one defined a model with these two parameters as inputs and `n_sample=2`, the following would be the output of `journal.get_parameters()`:
+If one defined a model with these two parameters as inputs and ``n_sample=2``, the following would be the output of ``journal.get_parameters()``:
 
 .. code-block:: python
 
@@ -45,7 +45,7 @@ For the post analysis basic functions are provided:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 63-66
+    :lines: 80-82
     :dedent: 4
 
 Also, to ensure reproducibility, every journal stores the parameters of the
@@ -53,18 +53,18 @@ algorithm that created it:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 69
+    :lines: 85
     :dedent: 4
 
-Finally, you can plot the inferred posterior mean of the parameters in the following way:
+Finally, you can plot the inferred posterior distribution of the parameters in the following way:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 77
+    :lines: 88
     :dedent: 4
 
-The above line plots the posterior distribution for all the parameters; if you instead want to plot it for some
-parameters only, you can use the `parameters_to_show` argument; in addition, the `ranges_parameters` argument can be
+The above line plots the posterior distribution for all the parameters and stores it in ``posterior.png``; if you instead want to plot it for some
+parameters only, you can use the ``parameters_to_show`` argument; in addition, the ``ranges_parameters`` argument can be
 used to provide a dictionary specifying the limits for the axis in the plots:
 
 .. code-block:: python
@@ -77,5 +77,5 @@ And certainly, a journal can easily be saved to and loaded from disk:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py
     :language: python
-    :lines: 72, 75
+    :lines: 91, 94
     :dedent: 4
diff --git a/doc/source/user_customization.rst b/doc/source/user_customization.rst
index 2bcf1f76..c032ec54 100644
--- a/doc/source/user_customization.rst
+++ b/doc/source/user_customization.rst
@@ -54,7 +54,7 @@ Since a Gaussian model generates continous numbers, the newly implemented class
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
    :language: python
-   :lines: 6, 11
+   :lines: 6, 9
 
 A good way to start implementing a new model is to define a convenient way to initialize it with its input parameters.
 In ABCpy all input parameters are either independent ProbabilisticModels or Hyperparameters. Thus, they should not be
@@ -74,7 +74,7 @@ the super class. This leads to the following implementation:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 16-25
+    :lines: 15-24
     :dedent: 4
     :linenos:
 
@@ -127,7 +127,7 @@ This leads to the following implementation:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 27-38
+    :lines: 26-37
     :dedent: 4
     :linenos:
 
@@ -144,7 +144,7 @@ A proper implementation look as follows:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 50-60
+    :lines: 49-59
     :dedent: 4
     :linenos:
 
@@ -171,7 +171,7 @@ Then, this function should return :code:`False` as soon as values are out of the
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 40-45
+    :lines: 39-44
     :dedent: 4
     :linenos:
 
@@ -192,7 +192,7 @@ Since our model generates a single float number in one forward simulation, the i
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 47-48
+    :lines: 46-47
     :dedent: 4
     :linenos:
 
@@ -215,7 +215,7 @@ as follows:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 62-66
+    :lines: 61-65
     :dedent: 4
     :linenos:
 
@@ -296,9 +296,9 @@ This creates two wrapper files `gaussian_model_simple_wrap.cpp` and
 Note that the include paths might need to be adapted to your system. Finally, we
 can write a Python model which uses our C++ code:
 
-.. literalinclude:: ../../examples/extensions/models/gaussian_cpp/pmcabc-gaussian_model_simple.py
+.. literalinclude:: ../../examples/extensions/models/gaussian_cpp/pmcabc_gaussian_model_simple.py
    :language: python
-   :lines: 1,4,6,8-62
+   :lines: 1,4,5-6,8,9-64
    :linenos:
 
 The important lines are where we import the wrapper code as a module (line 3) and call
@@ -320,15 +320,15 @@ example. The following R code is the contents of the R file `gaussian_model.R`:
 
 .. literalinclude:: ../../examples/extensions/models/gaussian_R/gaussian_model.R
     :language: R
-    :lines: 1 - 4
+    :lines: 1 - 5
     :linenos:
 
 More complex R models are incorporated in the same way. To include this function
 within ABCpy we include the following code at the beginning of our Python file:
 
-.. literalinclude:: ../../examples/extensions/models/gaussian_R/gaussian_model.py
+.. literalinclude:: ../../examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 4-5, 9-15
+    :lines: 5-6, 11-18, 20
     :linenos:
 
 This imports the R function :code:`simple_gaussian` into the Python environment.
@@ -336,9 +336,9 @@ We need to build our own model to incorporate this R function as in the previous
 section. The only difference is in the :code:`forward_simulate` method of the
 class :code:`Gaussian`.
 
-.. literalinclude:: ../../examples/extensions/models/gaussian_R/gaussian_model.py
+.. literalinclude:: ../../examples/extensions/models/gaussian_R/pmcabc_gaussian_model_simple.py
     :language: python
-    :lines: 61
+    :lines: 66
     :dedent: 8
     :linenos:
 
@@ -367,7 +367,7 @@ calculator should be provided. The following header conforms to this idea:
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 112-119
+    :lines: 109-116
     :dedent: 4
 
 Then, we need to define how the distance is calculated. First we compute the summary statistics from the datasets and
@@ -379,14 +379,14 @@ to save computation time of summary statistics from observed data, we save the s
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 121-155
+    :lines: 118-155
     :dedent: 4
 
 Finally, we need to define the maximal distance that can be obtained from this distance measure. 
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 158-159
+    :lines: 157-158
     :dedent: 4
 
 The newly defined distance class can be used in the same way as the already existing once. The complete example for this
@@ -513,5 +513,5 @@ Note that after defining your own kernel, you will need to collect all your kern
 :py:class:`JointPerturbationKernel <abcpy.perturbationkernel.JointPerturbationKernel>` object in order for inference to
 work. For an example on how to do this, check the :ref:`Using perturbation kernels <gettingstarted>` section.
 
-The complete example used in this tutorial can be found
-examples/extensions/perturbationkernels/multivariate_normal_kernel.py.
+The complete example used in this tutorial can be found in the file
+`examples/extensions/perturbationkernels/multivariate_normal_kernel.py`.

From a4100cb1bcfec601def8994c5c4a9756f1f04fcf Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 4 Nov 2020 18:31:09 +0100
Subject: [PATCH 088/106] Fix binder link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4a0ef85e..32435cb5 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy) [![DOI](https://zenodo.org/badge/doi/10.1145/3093172.3093233.svg)](http://dx.doi.org/10.1145/3093172.3093233) [![GitHub license](https://img.shields.io/github/license/eth-cscs/abcpy.svg)](https://github.com/eth-cscs/abcpy/blob/master/LICENSE) [![PyPI version shields.io](https://img.shields.io/pypi/v/abcpy.svg)](https://pypi.python.org/pypi/abcpy/) [![PyPI pyversions](https://img.shields.io/pypi/pyversions/abcpy.svg)](https://pypi.python.org/pypi/abcpy/)  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples%2Fgetting_started.ipynb)
+# ABCpy [![Documentation Status](https://readthedocs.org/projects/abcpy/badge/?version=latest)](http://abcpy.readthedocs.io/en/latest/?badge=latest) [![Build Status](https://travis-ci.org/eth-cscs/abcpy.svg?branch=master)](https://travis-ci.org/eth-cscs/abcpy) [![codecov](https://codecov.io/gh/eth-cscs/abcpy/branch/master/graph/badge.svg)](https://codecov.io/gh/eth-cscs/abcpy) [![DOI](https://zenodo.org/badge/doi/10.1145/3093172.3093233.svg)](http://dx.doi.org/10.1145/3093172.3093233) [![GitHub license](https://img.shields.io/github/license/eth-cscs/abcpy.svg)](https://github.com/eth-cscs/abcpy/blob/master/LICENSE) [![PyPI version shields.io](https://img.shields.io/pypi/v/abcpy.svg)](https://pypi.python.org/pypi/abcpy/) [![PyPI pyversions](https://img.shields.io/pypi/pyversions/abcpy.svg)](https://pypi.python.org/pypi/abcpy/)  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples)
 
 ABCpy is a scientific library written in Python for Bayesian uncertainty quantification in
 absence of likelihood function, which parallelizes existing approximate Bayesian computation (ABC) 

From 75465550ece12bab6f000e806e6cd0be1171cb2b Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 4 Nov 2020 16:09:17 +0100
Subject: [PATCH 089/106] Fix python scripts in docs

---
 doc/source/getting_started.rst |  4 ++++
 doc/source/parallelization.rst | 11 ++++++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst
index 3c27dbfb..5f4efc6f 100644
--- a/doc/source/getting_started.rst
+++ b/doc/source/getting_started.rst
@@ -7,6 +7,10 @@ Here, we explain how to use ABCpy to quantify parameter uncertainty of a probabi
 dataset. If you are new to uncertainty quantification using Approximate Bayesian Computation (ABC), we recommend you to
 start with the `Parameters as Random Variables`_ section.
 
+Moreover, we also provide an interactive notebook on Binder guiding through the basics of ABC with ABCpy; without
+installing that on your machine.
+Please find if `here <https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples>`_.
+
 Parameters as Random Variables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/doc/source/parallelization.rst b/doc/source/parallelization.rst
index 3d5b588a..7bc66789 100644
--- a/doc/source/parallelization.rst
+++ b/doc/source/parallelization.rst
@@ -69,7 +69,16 @@ a multiple of the ranks per communicator plus one additional rank for the
 master. For example, if we want to run n instances of a MPI model and allows m
 processes to each instance, we will have to spawn (n*m)+1 ranks.
 
-For `forward_simulation` of the MPI-parallelized simulator model has to be able 
+For instance, let's say you want to use n=3. Therefore, we use the following command:
+
+::
+
+    mpirun -n 7 python3 mpi/mpi_model_inferences.py
+
+as (3*2) + 1 = 7. Note that, in this scenario, using only 6 tasks overall leads to failure of the script due to how
+the tasks are assigned to the model instances.
+
+The `forward_simulation` method of the MPI-parallelized simulator model has to be able
 to take an MPI communicator as a parameter.
 
 An example of an MPI-parallelized simulator model, which can be used with ABCpy 

From b50b1e4dd497508c75a639076f94944d5cdf404f Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Wed, 4 Nov 2020 19:14:25 +0100
Subject: [PATCH 090/106] Add FORTRAN model in docs

---
 doc/source/user_customization.rst          | 40 ++++++++++++++++++++++
 examples/backends/dummy/pmcabc_gaussian.py |  2 --
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/doc/source/user_customization.rst b/doc/source/user_customization.rst
index c032ec54..b8f00b86 100644
--- a/doc/source/user_customization.rst
+++ b/doc/source/user_customization.rst
@@ -345,6 +345,46 @@ class :code:`Gaussian`.
 The default output for R functions in Python is a float vector. This must be
 converted into a Python numpy array for the purposes of ABCpy.
 
+Wrap a Model Written in FORTRAN
+-------------------------------
+
+FORTRAN is still a widely used language in some specific application domains. We show here how to wrap a FORTRAN model
+in ABCpy by exploiting the `F2PY <https://numpy.org/doc/stable/f2py/>`_ tool, which is part of Numpy.
+
+Using this tool is quite simple; first, the FORTRAN code defining the model has to be defined:
+
+.. literalinclude:: ../../examples/extensions/models/gaussian_f90/gaussian_model_simple.f90
+    :language: FORTRAN
+    :lines: 1 - 3
+
+specifically, that needs to define a subroutine (here ``gaussian``) in a module (here ``gaussian_model``):
+
+Then, the FORTRAN code needs to be compiled in a way which can be linked to the Python one; by using F2PY, this is as
+simple as:
+::
+
+    python -m numpy.f2py -c -m gaussian_model_simple gaussian_model_simple.f90
+
+which produces an executable (with ``.so`` extension on Linux, for instance) with the same name as the FORTRAN file.
+Finally, an ABCpy model in Python needs to be defined which calls the FORTRAN binary similarly to what done before.
+Specifically, we import the FORTRAN model in the following way:
+
+
+.. literalinclude:: ../../examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
+    :language: python
+    :lines: 5
+
+Note that the name of the object to import is the same as the module name in the original FORTRAN code. Then, in the
+``forward_simulate`` method of the ABCpy model, you can run the FORTRAN model and obtain its output with the following line:
+
+.. literalinclude:: ../../examples/extensions/models/gaussian_f90/pmcabc_gaussian_model_simple.py
+    :language: python
+    :lines: 52
+    :dedent: 8
+
+A full reproducible example is available in `examples/extensions/models/gaussion_f90/`; a Makefile with the right
+compilation commands is also provided.
+
 
 Implementing a new Distance
 ---------------------------
diff --git a/examples/backends/dummy/pmcabc_gaussian.py b/examples/backends/dummy/pmcabc_gaussian.py
index 91f0a2e9..c0e074c3 100644
--- a/examples/backends/dummy/pmcabc_gaussian.py
+++ b/examples/backends/dummy/pmcabc_gaussian.py
@@ -3,8 +3,6 @@
 import numpy as np
 
 
-
-
 def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN):
     """Perform inference for this example.
 

From ef4bcac66694bfd223204e61614a0f69b52aea7a Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 11:44:15 +0100
Subject: [PATCH 091/106] Add small remark on ESS/Wass_dist convergence checks

---
 doc/source/postanalysis.rst | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst
index 903f5475..8a75d4a6 100644
--- a/doc/source/postanalysis.rst
+++ b/doc/source/postanalysis.rst
@@ -73,6 +73,16 @@ used to provide a dictionary specifying the limits for the axis in the plots:
                                  ranges_parameters={'parameter_1': [0,2]})
 
 
+For journals generated with sequential algorithms, we provide a way to monitor the convergence by plotting the estimated
+Effective Sample Size (ESS) at each iteration, as well as an estimate of the Wasserstein distance between the empirical
+distributions defined by the samples and weights at subsequent iterations:
+
+.. code-block:: python
+
+    journal.plot_ESS()
+    journal.Wass_convergence_plot()
+
+
 And certainly, a journal can easily be saved to and loaded from disk:
 
 .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py

From d5f44681945feae986de0ccc790bc77a9119999a Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 11:58:40 +0100
Subject: [PATCH 092/106] Add new notebook

---
 doc/source/ABC_rejection.png             | Bin 0 -> 71582 bytes
 examples/Rejection_ABC_closer_look.ipynb | 632 +++++++++++++++++++++++
 2 files changed, 632 insertions(+)
 create mode 100644 doc/source/ABC_rejection.png
 create mode 100644 examples/Rejection_ABC_closer_look.ipynb

diff --git a/doc/source/ABC_rejection.png b/doc/source/ABC_rejection.png
new file mode 100644
index 0000000000000000000000000000000000000000..5cf4f820d66b7a4523fa0d88cfe5bb8466356ac4
GIT binary patch
literal 71582
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

literal 0
HcmV?d00001

diff --git a/examples/Rejection_ABC_closer_look.ipynb b/examples/Rejection_ABC_closer_look.ipynb
new file mode 100644
index 00000000..05016290
--- /dev/null
+++ b/examples/Rejection_ABC_closer_look.ipynb
@@ -0,0 +1,632 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "notes"
+    }
+   },
+   "source": [
+    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples%2FRejection_ABC_closer_look.ipynb)\n",
+    "\n",
+    "# A closer look to Rejection ABC\n",
+    "\n",
+    "In this notebook, we give some insights on how Rejection ABC (and ABC in general) works, using `ABCpy`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Approximate Bayesian Computation (ABC)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "source": [
+    "Approximate Bayesian Computation is a set of methods that allow to find the 'best' parameters of a scientific model with respect to observations from the real world. More specifically, ABC sits in the set of Bayesian inference methods; therefore, it provides the user not only with a point estimate of parameter values, but with a _posterior_ distribution quantifying uncertainty.\n",
+    "\n",
+    "\n",
+    "To infer the parameters of a model using ABC, three basic ingredients are required:\n",
+    "- A model is required that, given some input parameters, can generate synthetic observations\n",
+    "- Some prior knowledge about the input parameters is required (a Uniform distribution over the parameters space is always possible)\n",
+    "- A discrepancy function is required that quantifies how similar two sets of observations (real and synthetic) are. Here, we will use the simple Euclidean distance between observations.\n",
+    "\n",
+    "**Note: we do not need the likelihood function of the bi-variate normal distribution!**\n",
+    "\n",
+    "In this model, we will consider a setup in which a scientist measures height and weigth of a set of people and wants to use a statistical model to describe them; moreover, she also wants to find the posterior distributon over parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from math import cos, sin, pi\n",
+    "\n",
+    "import matplotlib.mlab as mlab\n",
+    "import numpy as np\n",
+    "import scipy\n",
+    "from matplotlib import gridspec, pyplot as plt\n",
+    "from numpy.linalg import inv\n",
+    "from scipy.stats import multivariate_normal\n",
+    "from abcpy.probabilisticmodels import ProbabilisticModel, Continuous, InputConnector\n",
+    "from abcpy.continuousmodels import Uniform\n",
+    "from abcpy.statistics import Identity\n",
+    "from abcpy.distances import Euclidean\n",
+    "from abcpy.inferences import RejectionABC\n",
+    "from abcpy.backends import BackendDummy as Backend\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us define the model we will consider; this is specifically a bivariate normal model, in which the covariance matrix is defined in the following way (method `get_cov`): \n",
+    "\n",
+    "- the standard deviations s1 and s2 are used to define a diagonal covariance matrix\n",
+    "- then, a rotation matrix corresponding to angle alpha is used to rotate that to a correlated covariance matrix. \n",
+    "\n",
+    "Essentially, then, s1 and s2 are the standard deviation of the final bivariate normal along the directions in which the two components are uncorrelated. This is related to eigendecomposition, but this is not the main point here. \n",
+    "\n",
+    "We use `ABCpy` API to define the model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class BivariateNormal(ProbabilisticModel, Continuous):\n",
+    "\n",
+    "    def __init__(self, parameters, name='BivariateNormal'):\n",
+    "        # We expect input of type parameters = [m1, m2, s1, s2, alpha]\n",
+    "        if not isinstance(parameters, list):\n",
+    "            raise TypeError('Input of Normal model is of type list')\n",
+    "\n",
+    "        if len(parameters) != 5:\n",
+    "            raise RuntimeError('Input list must be of length 5, containing [m1, m2, s1, s2, alpha].')\n",
+    "\n",
+    "        input_connector = InputConnector.from_list(parameters)\n",
+    "        super().__init__(input_connector, name)\n",
+    "\n",
+    "    def _check_input(self, input_values):\n",
+    "        # Check whether input has correct type or format\n",
+    "        if len(input_values) != 5:\n",
+    "            raise ValueError('Number of parameters of BivariateNormal model must be 5.')\n",
+    "\n",
+    "        # Check whether input is from correct domain\n",
+    "        m1 = input_values[0]\n",
+    "        m2 = input_values[1]\n",
+    "        s1 = input_values[2]\n",
+    "        s2 = input_values[3]\n",
+    "        alpha = input_values[4]\n",
+    "        if s1 < 0 or s2 < 0:\n",
+    "            return False\n",
+    "\n",
+    "        return True\n",
+    "\n",
+    "    def _check_output(self, values):\n",
+    "        if not isinstance(values, np.array):\n",
+    "            raise ValueError('This returns a bivariate array')\n",
+    "        \n",
+    "        if values.shape[0] != 2: \n",
+    "            raise RuntimeError('The size of the output has to be 2.')\n",
+    "        \n",
+    "        return True\n",
+    "\n",
+    "    def get_output_dimension(self):\n",
+    "        return 2\n",
+    "\n",
+    "    def forward_simulate(self, input_values, k, rng=np.random.RandomState()):\n",
+    "        # Extract the input parameters\n",
+    "        m1 = input_values[0]\n",
+    "        m2 = input_values[1]\n",
+    "        s1 = input_values[2]\n",
+    "        s2 = input_values[3]\n",
+    "        alpha = input_values[4]\n",
+    "        \n",
+    "        mean = np.array([m1, m2])\n",
+    "        cov = self.get_cov(s1, s2, alpha)\n",
+    "        \n",
+    "        obs_pd = multivariate_normal(mean=mean, cov=cov)\n",
+    "        vector_of_k_samples = obs_pd.rvs(k)\n",
+    "\n",
+    "        # Format the output to obey API\n",
+    "        result = [np.array([x]) for x in vector_of_k_samples]\n",
+    "        return result\n",
+    "\n",
+    "    def get_cov(self, s1, s2, alpha):\n",
+    "        \"\"\"Function to generate a covariance bivariate covariance matrix; it starts from considering a\n",
+    "        diagonal covariance matrix with standard deviations s1, s2 and then applies the rotation matrix with \n",
+    "        angle alpha. \"\"\"\n",
+    "        r = np.array([[cos(alpha), -sin(alpha)], [sin(alpha), cos(alpha)]]) # Rotation matrix\n",
+    "        e = np.array([[s1, 0], [0, s2]]) # Eigenvalue matrix\n",
+    "        rde = np.dot(r, e)\n",
+    "        rt = np.transpose(r)\n",
+    "        cov = np.dot(rde, rt)\n",
+    "        return cov"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we define some help functions for plots:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def plot_dspace(ax, sl, marker, color):\n",
+    "    \"\"\"Plot the data in 'sl' on 'ax';\"\"\"\n",
+    "    ax.set_xlim(100,220)\n",
+    "    ax.set_ylim(30,150)\n",
+    "    ax.set_xlabel('Height in cm')\n",
+    "    ax.set_ylabel('Weigth in kg')\n",
+    "    for samples in sl:\n",
+    "        ax.plot(samples[:,0], samples[:,1], marker, c=color)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def plot_pspace(ax_means, ax_vars, ax_angle, m1, m2, s1, s2, alpha, color):\n",
+    "    \"\"\"Plot parameter space. m1 and m2 are the means of the height and weight respectively, while s1, s2 are \n",
+    "    two standard deviations for the eigenvalue normal components. Finally, alpha is the angle that determines the \n",
+    "    amount of rotation applied to the two independent components to get the covariance matrix.\"\"\"\n",
+    "    ax_means.set_xlabel('Mean of height')\n",
+    "    ax_means.set_ylabel('Mean of weight')\n",
+    "    ax_means.set_xlim(120,200)\n",
+    "    ax_means.set_ylim(50,150)\n",
+    "    ax_means.plot(m1, m2, 'o', c=color)\n",
+    "\n",
+    "    ax_vars.set_xlabel('Standard deviation 1')\n",
+    "    ax_vars.set_ylabel('Standard deviation 2')\n",
+    "    ax_vars.set_xlim(0,100)\n",
+    "    ax_vars.set_ylim(0,100)\n",
+    "    ax_vars.plot(s1, s2, 'o', c=color)\n",
+    "    \n",
+    "    ax_angle.set_xlabel('Rotation angle')\n",
+    "    ax_angle.set_xlim(0, pi/2)\n",
+    "    ax_angle.set_yticks([])\n",
+    "    ax_angle.plot(np.linspace(0, pi, 10), [0]*10, c='black', linewidth=0.2)\n",
+    "    ax_angle.plot(alpha, 0, 'o', c=color)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def plot_all(axs, m1, m2, s1, s2, alpha, color, marker, model, k):\n",
+    "    \"\"\"Function plotting pameters, generating data from them and plotting data too. It uses the model \n",
+    "    to generate k samples from the provided set of parameters. \n",
+    "    \n",
+    "    m1 and m2 are the means of the height and weight respectively, while s1, s2 are \n",
+    "    two standard deviations for the eigenvalue normal components. Finally, alpha is the angle that determines the \n",
+    "    amount of rotation applied to the two independent components to get the covariance matrix.\n",
+    "    \"\"\"\n",
+    "    ax_pspace_means, ax_pspace_vars, ax_pspace_angle, ax_dspace = axs\n",
+    "    plot_pspace(ax_pspace_means, ax_pspace_vars, ax_pspace_angle, m1, m2, s1, s2, alpha, color)\n",
+    "    samples = model.forward_simulate([m1, m2, s1, s2, alpha], k)\n",
+    "    plot_dspace(ax_dspace, samples, marker, color)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define now the probabilistic model; we put uniform priors on the parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m1 = Uniform([[120], [200]], name=\"Mean_height\")\n",
+    "m2 = Uniform([[50], [150]], name=\"Mean_weigth\")\n",
+    "s1 = Uniform([[0], [100]], name=\"sd_1\")\n",
+    "s2 = Uniform([[0], [100]], name=\"sd_2\")\n",
+    "alpha = Uniform([[0], [pi/2]], name=\"alpha\")\n",
+    "\n",
+    "bivariate_normal = BivariateNormal([m1, m2, s1, s2, alpha])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Assume now that the scientist obtained an observation, from field data, that was generated by the model with a specific set of parameters `obs_par`; this is of course fictitious, but we take this assumption in order to check whether we are able to recover decently the actual model parameters we used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "obs_par = np.array([175, 75, 90, 35, pi/4.])\n",
+    "obs = bivariate_normal.forward_simulate(obs_par, 100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2700x2700 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig_obs = plt.figure(dpi=300)\n",
+    "fig_obs.set_size_inches(9,9)\n",
+    "ax_obs = fig_obs.add_subplot(111)\n",
+    "ax_obs.set_title('Observations')\n",
+    "plot_dspace(ax_obs, obs, 'x', 'C0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Rejection ABC\n",
+    "This is the most fundamental algorithm for ABC; it works in four steps:\n",
+    "\n",
+    "Repeat:\n",
+    "1. draw a parameter sample theta from the prior\n",
+    "2. generate synthetic observations from the model using theta\n",
+    "3. compute the distance between observed and synthetic data\n",
+    "4. if the distance is smaller than a threshold, add theta to accepted parameters\n",
+    "\n",
+    "And the loop continues until enough parameter values are accepted. The output is a set of accepted parameters, that resembles the parameters 'true' (posterior) distribution.\n",
+    "\n",
+    "\n",
+    "![Rejection ABC image](https://github.com/eth-cscs/abcpy/raw/master/doc/source/ABC_rejection.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### RejectionABC in Figures\n",
+    "We will now display the observations generated from the model for a set of parameter values; specifically, we consider 4 different sets of parameter values (corresponding to the four different colors) which are displayed in the left hand side set of plot; the corresponding observations are of the same color in the right plot; in the latter, we also show the observation (blue).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": false,
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2850x1350 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(0)\n",
+    "fig_sim = plt.figure(dpi=150)\n",
+    "fig_sim.set_size_inches(19, 9)\n",
+    "gs = gridspec.GridSpec(1, 2, width_ratios=[1,1], height_ratios=[1])\n",
+    "gs_pspace = gridspec.GridSpecFromSubplotSpec(2, 2, subplot_spec=gs[0,0], width_ratios=[1, 1], height_ratios=[4,1])\n",
+    "ax_pspace_means = plt.subplot(gs_pspace[0,0])\n",
+    "ax_pspace_vars = plt.subplot(gs_pspace[0,1])\n",
+    "ax_pspace_angle = plt.subplot(gs_pspace[1,:])\n",
+    "ax_dspace = plt.subplot(gs[0,1])\n",
+    "axs = (ax_pspace_means, ax_pspace_vars, ax_pspace_angle, ax_dspace)\n",
+    "\n",
+    "#plot_dspace(ax_dspace, [obs], 'x', 'C0')\n",
+    "plot_all(axs, 130,110,95,50,pi/5, 'C1', 'x', bivariate_normal, 100)\n",
+    "plot_all(axs, 170,80,60,5,0.3, 'C2', 'x', bivariate_normal, 100)\n",
+    "plot_all(axs, 135,55,10,70,1.3, 'C3', 'x', bivariate_normal, 100)\n",
+    "plot_all(axs, 190,120,21,21,pi/3., 'C4', 'x', bivariate_normal, 100)\n",
+    "plot_dspace(ax_dspace, obs, 'X', 'C0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The idea of ABC is the following: similar data sets come from similar sets of parameters. For this reason, to obtain the best parameter values which fit the observation, we will compare the observation with the synthetic data for different choices of parameters, for instance, above you can see that the green dataset is a better match for the observation than the others."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "Let us now generate some samples from the prior and see how well they fit the observation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_prior_samples = 100\n",
+    "params_prior = np.zeros((n_prior_samples,5))\n",
+    "\n",
+    "for i in range(n_prior_samples):\n",
+    "    m1_val = m1.forward_simulate([[120], [200]], k=1)\n",
+    "    m2_val = m2.forward_simulate([[50], [150]], k=1)\n",
+    "    s1_val = s1.forward_simulate([[0], [100]], k=1)\n",
+    "    s2_val = s2.forward_simulate([[0], [100]], k=1)\n",
+    "    alpha_val = alpha.forward_simulate([[0], [pi / 2]], k=1)\n",
+    "    \n",
+    "    params_prior[i] = np.array([m1_val, m2_val, s1_val, s2_val, alpha_val]).squeeze()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2850x1350 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(0)\n",
+    "fig_abc1 = plt.figure(dpi=150)\n",
+    "fig_abc1.set_size_inches(19, 9)\n",
+    "gs = gridspec.GridSpec(1, 2, width_ratios=[1,1], height_ratios=[1])\n",
+    "gs_pspace = gridspec.GridSpecFromSubplotSpec(2, 2, subplot_spec=gs[0,0], width_ratios=[1, 1], height_ratios=[4,1])\n",
+    "ax_pspace_means = plt.subplot(gs_pspace[0,0])\n",
+    "ax_pspace_vars = plt.subplot(gs_pspace[0,1])\n",
+    "ax_pspace_angle = plt.subplot(gs_pspace[1,:])\n",
+    "ax_dspace = plt.subplot(gs[0,1])\n",
+    "axs = (ax_pspace_means, ax_pspace_vars, ax_pspace_angle, ax_dspace)\n",
+    "\n",
+    "for i in range(0, n_prior_samples):\n",
+    "    plot_all(axs, params_prior[i,0], params_prior[i,1], params_prior[i,2], params_prior[i,3], params_prior[i,4], \n",
+    "             'C1', '.', bivariate_normal, k=100)\n",
+    "\n",
+    "plot_pspace(ax_pspace_means, ax_pspace_vars, ax_pspace_angle, *obs_par, color=\"C0\")\n",
+    "plot_dspace(ax_dspace, obs, 'X', 'C0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Above, the blue dot represent the parameter values which originated the observation, while the orange parameter values are the ones sampled from the prior; the corresponding synthetic datasets are shown as orange clouds of dots, while the observation is shown as blue crosses."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Inference\n",
+    "Now, let's perform inference with Rejection ABC to get some approximate posterior samples: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "statistics_calculator = Identity()\n",
+    "distance_calculator = Euclidean(statistics_calculator)\n",
+    "backend = Backend()\n",
+    "\n",
+    "sampler = RejectionABC([bivariate_normal], [distance_calculator], backend, seed=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sampling may take a while. It will take longer the more you decrease the threshold epsilon or increase the number of samples. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_samples = 100  # number of posterior samples we aim for\n",
+    "n_samples_per_param = 100  # number of simulations for each set of parameter values\n",
+    "journal = sampler.sample([obs], n_samples, n_samples_per_param, epsilon=15)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3732]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(journal.number_of_simulations)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we will produce a plot similar to the above one for the prior but starting from the posterior samples. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "posterior_samples = np.array(journal.get_accepted_parameters()).squeeze()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2850x1350 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(0)\n",
+    "fig_abc1 = plt.figure(dpi=150)\n",
+    "fig_abc1.set_size_inches(19, 9)\n",
+    "gs = gridspec.GridSpec(1, 2, width_ratios=[1,1], height_ratios=[1])\n",
+    "gs_pspace = gridspec.GridSpecFromSubplotSpec(2, 2, subplot_spec=gs[0,0], width_ratios=[1, 1], height_ratios=[4,1])\n",
+    "ax_pspace_means = plt.subplot(gs_pspace[0,0])\n",
+    "ax_pspace_vars = plt.subplot(gs_pspace[0,1])\n",
+    "ax_pspace_angle = plt.subplot(gs_pspace[1,:])\n",
+    "ax_dspace = plt.subplot(gs[0,1])\n",
+    "axs = (ax_pspace_means, ax_pspace_vars, ax_pspace_angle, ax_dspace)\n",
+    "\n",
+    "for i in range(0, n_samples):\n",
+    "    plot_all(axs, posterior_samples[i,0], posterior_samples[i,1], posterior_samples[i,2], posterior_samples[i,3], \n",
+    "             posterior_samples[i,4], 'C1', '.', bivariate_normal, k=100)\n",
+    "    \n",
+    "plot_pspace(ax_pspace_means, ax_pspace_vars, ax_pspace_angle, *obs_par, color=\"C0\")\n",
+    "plot_dspace(ax_dspace, obs, 'X', 'C0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, you can see that the sythetic datasets are much closer to the observation. Also, the parameter values which generated those are not anymore evenly spread on the parameter space.\n",
+    "\n",
+    "The mean parameters are very much concentrated close to the exact parameter value; with regards to the other ones, they are a bit more spread out."
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

From b0a7029ba009d0d717fedf754cf6b542a0f9ad4c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 14:04:04 +0100
Subject: [PATCH 093/106] Additional info on installation

---
 doc/source/installation.rst | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/doc/source/installation.rst b/doc/source/installation.rst
index 22e1f832..b6773432 100644
--- a/doc/source/installation.rst
+++ b/doc/source/installation.rst
@@ -11,6 +11,7 @@ Installation from PyPI
 
 Simplest way to install 
 ::
+
    pip3 install abcpy
 
 This also works in a virtual environment.
@@ -34,9 +35,10 @@ To create a package and install it, do
 ::
 
    make package
+   pip3 install wheel
+   pip3 install build/dist/abcpy-0.6.0-py3-none-any.whl
 
-   pip3 install build/dist/abcpy-0.5.6-py3-none-any.whl
-
+``wheel`` is required to install in this way.
 
 Note that ABCpy requires Python3.
 
@@ -65,15 +67,18 @@ Troubleshooting ``mpi4py`` installation
 ``mpi4py`` requires a working MPI implementation to be installed; check the `official docs
 <https://mpi4py.readthedocs.io/en/stable/install.html>`_ for more info. On Ubuntu, that can be installed with:
 ::
+
     sudo apt-get install libopenmpi-dev
 
 Even when that is present, running ``pip install mpi4py`` can sometimes lead to errors. In fact, as specified in the `official docs
 <https://mpi4py.readthedocs.io/en/stable/install.html>`_, the ``mpicc`` compiler needs to be in the search path. If that is not the case, a workaround is:
 ::
+
     env MPICC=/path/to/mpicc pip install mpi4py
 
 In some cases, even the above may not be enough. A possibility is using ``conda`` (``conda install mpi4py``) which usually handles package dependencies better than ``pip``. Alternatively, you can try by installing directly ``mpi4py`` from the package manager; in Ubuntu, you can do:
 ::
+
     sudo apt install python3-mpi4py
 
 which however does not work with virtual environments.

From 3b1ccbeb7c9e115c7f842f4881d5af435151a3d4 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 14:25:06 +0100
Subject: [PATCH 094/106] Add MANIFEST.in file to include requirements in
 source distribution; useful for conda deployment in the future

---
 MANIFEST.in | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 MANIFEST.in

diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..540b7204
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1 @@
+include requirements.txt
\ No newline at end of file

From 9a014b206df9b5c08a5b772b10d9f033e2ba6c3b Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 15:09:23 +0100
Subject: [PATCH 095/106] Add MANIFEST.in file to include requirements in
 source distribution; useful for conda deployment in the future

---
 MANIFEST.in | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 MANIFEST.in

diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..540b7204
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1 @@
+include requirements.txt
\ No newline at end of file

From f513312d00b23d1a7192cce9bd3b4e310cbf2682 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 16:52:20 +0100
Subject: [PATCH 096/106] Fix VERSION

---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index d1d899fa..a918a2aa 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.5.5
+0.6.0

From f969e1d1f675604344148095ff7cafffbcea1c96 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 17:15:07 +0100
Subject: [PATCH 097/106] Small fix in docs

---
 Makefile                    | 2 +-
 doc/source/postanalysis.rst | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 3857b4a8..f92a5f65 100644
--- a/Makefile
+++ b/Makefile
@@ -44,7 +44,7 @@ doctest:
 	make -C doc html || (echo "Error in documentation generator."; exit 1)
 
 coveragetest: $(MAKEDIRS)  # compile models here as well as we check them for codecov as well.
-	command -v coverage >/dev/null 2>&1 || { echo >&2 "Python package 'coverage' has to been installed. Please, run 'pip3 install coverage'."; exit;}
+	@command -v coverage >/dev/null 2>&1 || { echo >&2 "Python package 'coverage' has to been installed. Please, run 'pip3 install coverage'."; exit;}
 	# unittests
 	@- $(foreach TEST, $(UNITTESTS), \
 		echo === Testing code coverage: $(TEST); \
diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst
index 8a75d4a6..260cea05 100644
--- a/doc/source/postanalysis.rst
+++ b/doc/source/postanalysis.rst
@@ -73,7 +73,7 @@ used to provide a dictionary specifying the limits for the axis in the plots:
                                  ranges_parameters={'parameter_1': [0,2]})
 
 
-For journals generated with sequential algorithms, we provide a way to monitor the convergence by plotting the estimated
+For journals generated with sequential algorithms, we provide a way to check the convergence by plotting the estimated
 Effective Sample Size (ESS) at each iteration, as well as an estimate of the Wasserstein distance between the empirical
 distributions defined by the samples and weights at subsequent iterations:
 

From ca5afe7609994409ca8cc0720e0920975f2eb85c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Thu, 5 Nov 2020 17:34:08 +0100
Subject: [PATCH 098/106] Fix tests; improve coverage too

---
 abcpy/output.py                   |  1 -
 tests/output_tests.py             |  4 ++
 tests/perturbationkernel_tests.py | 70 +++++++++++++++++++++++++++++--
 tests/statisticslearning_tests.py | 36 ++++++++++------
 4 files changed, 94 insertions(+), 17 deletions(-)

diff --git a/abcpy/output.py b/abcpy/output.py
index e591075b..887a6880 100644
--- a/abcpy/output.py
+++ b/abcpy/output.py
@@ -846,7 +846,6 @@ def Wass_convergence_plot(self, num_iter_max=1e8, **kwargs):
         wass_dist_lists = [None] * (len(self.weights) - 1)
 
         for i in range(len(self.weights) - 1):
-            print(i)
             params_1 = self.get_accepted_parameters(i)
             params_2 = self.get_accepted_parameters(i + 1)
             weights_1 = self.get_weights(i)
diff --git a/tests/output_tests.py b/tests/output_tests.py
index 81662448..12e7fe14 100644
--- a/tests/output_tests.py
+++ b/tests/output_tests.py
@@ -150,6 +150,7 @@ def test_plot_post_distr(self):
         journal.add_weights(weights=weights_identical)
         journal.add_weights(weights=weights)
         journal.plot_posterior_distr(single_marginals_only=True, iteration=0)
+        journal.plot_posterior_distr(true_parameter_values=[0.5, 0.3], show_samples=True)
         journal.plot_posterior_distr(double_marginals_only=True, show_samples=True,
                                      true_parameter_values=[0.5, 0.3])
         journal.plot_posterior_distr(contour_levels=10, ranges_parameters={"par1": [-1, 1]},
@@ -159,10 +160,13 @@ def test_plot_post_distr(self):
             journal.plot_posterior_distr(parameters_to_show=["par3"])
         with self.assertRaises(RuntimeError):
             journal.plot_posterior_distr(single_marginals_only=True, double_marginals_only=True)
+        with self.assertRaises(RuntimeError):
             journal.plot_posterior_distr(parameters_to_show=["par1"], double_marginals_only=True)
+        with self.assertRaises(RuntimeError):
             journal.plot_posterior_distr(parameters_to_show=["par1"], true_parameter_values=[0.5, 0.3])
         with self.assertRaises(TypeError):
             journal.plot_posterior_distr(ranges_parameters={"par1": [-1]})
+        with self.assertRaises(TypeError):
             journal.plot_posterior_distr(ranges_parameters={"par1": np.zeros(1)})
 
 
diff --git a/tests/perturbationkernel_tests.py b/tests/perturbationkernel_tests.py
index d4b961a0..4f959f68 100644
--- a/tests/perturbationkernel_tests.py
+++ b/tests/perturbationkernel_tests.py
@@ -29,10 +29,10 @@ def test_doesnt_raise(self):
             self.fail("JointPerturbationKernel raises an exception")
 
 
-class CalculateCovTets(unittest.TestCase):
+class CalculateCovTest(unittest.TestCase):
     """Tests whether the implementation of calculate_cov is working as intended."""
 
-    def test(self):
+    def test_default(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
         N2 = Normal([0.3, N1])
@@ -55,6 +55,27 @@ def test(self):
 
         self.assertTrue(not (covs[1]))
 
+    def test_Student_T(self):
+        N1 = Normal([0.1, 0.01])
+        N2 = Normal([0.3, N1])
+        graph = Normal([N1, N2])
+
+        Manager = AcceptedParametersManager([graph])
+        backend = Backend()
+        kernel = JointPerturbationKernel([MultivariateStudentTKernel([N1, N2], df=2)])
+        Manager.update_broadcast(backend, [[0.27, 0.097], [0.32, 0.012]], np.array([1, 1]))
+
+        kernel_parameters = []
+        for krnl in kernel.kernels:
+            kernel_parameters.append(Manager.get_accepted_parameters_bds_values(krnl.models))
+        Manager.update_kernel_values(backend, kernel_parameters)
+
+        covs = kernel.calculate_cov(Manager)
+        print(covs)
+        self.assertTrue(len(covs) == 1)
+
+        self.assertTrue(len(covs[0]) == 2)
+
 
 class UpdateTests(unittest.TestCase):
     """Tests whether the values returned after perturbation are in the correct format for each perturbation kernel."""
@@ -83,11 +104,35 @@ def test_DefaultKernel(self):
         self.assertEqual(perturbed_values_and_models,
                          [(N1, [0.17443453636632419]), (N2, [0.25882435863499248]), (B1, [3])])
 
+    def test_Student_T(self):
+        N1 = Normal([0.1, 0.01])
+        N2 = Normal([0.3, N1])
+        graph = Normal([N1, N2])
+
+        Manager = AcceptedParametersManager([graph])
+        backend = Backend()
+        kernel = JointPerturbationKernel([MultivariateStudentTKernel([N1, N2], df=2)])
+        Manager.update_broadcast(backend, [[0.27, 0.097], [0.32, 0.012]], np.array([1, 1]),
+                                 accepted_cov_mats=[[[0.01, 0], [0, 0.01]], []])
+
+        kernel_parameters = []
+        for krnl in kernel.kernels:
+            kernel_parameters.append(
+                Manager.get_accepted_parameters_bds_values(krnl.models))
+
+        Manager.update_kernel_values(backend, kernel_parameters=kernel_parameters)
+
+        rng = np.random.RandomState(1)
+        perturbed_values_and_models = kernel.update(Manager, 1, rng)
+        print(perturbed_values_and_models)
+        self.assertEqual(perturbed_values_and_models,
+                         [(N1, [0.2107982411716391]), (N2, [-0.049106838502166614])])
+
 
 class PdfTests(unittest.TestCase):
     """Tests whether the pdf returns the correct results."""
 
-    def test_return_value(self):
+    def test_return_value_default_kernel(self):
         B1 = Binomial([10, 0.2])
         N1 = Normal([0.1, 0.01])
         N2 = Normal([0.3, N1])
@@ -107,6 +152,25 @@ def test_return_value(self):
         pdf = kernel.pdf(mapping, Manager, Manager.accepted_parameters_bds.value()[1], [2, 0.3, 0.1])
         self.assertTrue(isinstance(pdf, float))
 
+    def test_return_value_Student_T(self):
+        N1 = Normal([0.1, 0.01])
+        N2 = Normal([0.3, N1])
+        graph = Normal([N1, N2])
+
+        Manager = AcceptedParametersManager([graph])
+        backend = Backend()
+        kernel = JointPerturbationKernel([MultivariateStudentTKernel([N1, N2], df=2)])
+        Manager.update_broadcast(backend, [[0.4, 0.09], [0.2, 0.008]], np.array([0.5, 0.2]))
+        kernel_parameters = []
+        for krnl in kernel.kernels:
+            kernel_parameters.append(Manager.get_accepted_parameters_bds_values(krnl.models))
+        Manager.update_kernel_values(backend, kernel_parameters)
+        mapping, mapping_index = Manager.get_mapping(Manager.model)
+        covs = [[[1, 0], [0, 1]], []]
+        Manager.update_broadcast(backend, accepted_cov_mats=covs)
+        pdf = kernel.pdf(mapping, Manager, Manager.accepted_parameters_bds.value()[1], [0.3, 0.1])
+        self.assertTrue(isinstance(pdf, float))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py
index d162e1ca..7fffd7c2 100644
--- a/tests/statisticslearning_tests.py
+++ b/tests/statisticslearning_tests.py
@@ -98,34 +98,44 @@ def test_errors(self):
         with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
                                                       n_samples_per_param=1, seed=1, parameters=np.ones((100, 1)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)))
+                                                  n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3)))
+                                                  n_samples_per_param=1, seed=1, simulations=np.ones((100, 1, 3)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2)))
+                                                  n_samples_per_param=1, seed=1, parameters=np.ones((100, 1, 2)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)),
-                                                      parameters=np.zeros((99, 1)))
+                                                  n_samples_per_param=1, seed=1, simulations=np.ones((100, 1)),
+                                                  parameters=np.zeros((99, 1)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1)))
+                                                  n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)))
+                                                  n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3)))
+                                                  n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1, 3)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2)))
+                                                  n_samples_per_param=1, seed=1, parameters_val=np.ones((100, 1, 2)))
+        with self.assertRaises(RuntimeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)),
+                                                  n_samples_per_param=1, seed=1, simulations_val=np.ones((100, 1)),
                                                       parameters_val=np.zeros((99, 1)))
         with self.assertRaises(TypeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
                                                       n_samples_per_param=1, seed=1, parameters=[i for i in range(10)],
                                                       simulations=[i for i in range(10)])
+        with self.assertRaises(TypeError):
             self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=1000,
-                                                      n_samples_per_param=1, seed=1,
-                                                      parameters_val=[i for i in range(10)],
-                                                      simulations_val=[i for i in range(10)])
+                                                  n_samples_per_param=1, seed=1,
+                                                  parameters_val=[i for i in range(10)],
+                                                  simulations_val=[i for i in range(10)])
 
 
 class ContrastiveDistanceLearningTests(unittest.TestCase):

From a5b78ee435367239a576a1b215ef1fd1f0cc8fed Mon Sep 17 00:00:00 2001
From: statrita2004 <statrita2004@gmail.com>
Date: Thu, 5 Nov 2020 20:03:26 +0000
Subject: [PATCH 099/106] Updates in publication using ABCpy

---
 README.md                      | 11 ++++++-----
 doc/source/getting_started.rst |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 32435cb5..12bd82c8 100644
--- a/README.md
+++ b/README.md
@@ -70,11 +70,8 @@ which however does not work with virtual environments.
 
 # Author 
 ABCpy was written by [Ritabrata Dutta, Warwick
-University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/)
-and [Marcel Schoengens](schoengens@cscs.ch), CSCS, ETH Zurich, and we're
-actively developing it. Please feel free to submit any bugs or feature requests.
-We'd also love to hear about your experiences with ABCpy in general. Drop us an
-email!
+University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/) and [Marcel Schoengens](mschoengens@bitvalve.org), CSCS, ETH Zurich, and presently actively maintained by [Lorenzo Pacchiardi](https://github.com/LoryPack) and [Ritabrata Dutta, Warwick
+University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/). Please feel free to submit any bugs or feature requests. We'd also love to hear about your experiences with ABCpy in general. Drop us an email!
 
 We want to thank [Prof. Antonietta Mira, Università della svizzera
 italiana](https://search.usi.ch/en/people/f8960de6d60dd08a79b6c1eb20b7442b/Mira-Antonietta),
@@ -95,6 +92,10 @@ ABCpy for your publication, we would appreciate a citation. You can use
 
 Publications in which ABCpy was applied:
 
+* R. Dutta, K. Zouaoui-Boudjeltia, C. Kotsalos, A. Rousseau, D. Ribeiro de Sousa, J. M. Desmet, A. Van Meerhaeghe, A. Mira, and B. Chopard. "Interpretable pathological test for Cardio-vascular disease: Approximate Bayesian computation with distance learning." arXiv preprint arXiv:2010.06465 (2020).
+
+* R. Dutta, S. Gomes, D. Kalise, L. Pacchiardi. "Using mobility data in the design of optimal lockdown strategies for the COVID-19 pandemic in England." arXiv preprint arXiv:2006.16059 (2020).
+
 * L. Pacchiardi, P. K&#252;nzli, M. Sch&#246;ngens, B. Chopard, R. Dutta, "Distance-Learning for Approximate Bayesian
   Computation to Model a Volcanic Eruption", 2020, Sankhya B, ISSN 0976-8394, 
   [DOI: 10.1007/s13571-019-00208-8](https://doi.org/10.1007/s13571-019-00208-8).
diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst
index 5f4efc6f..08d14e30 100644
--- a/doc/source/getting_started.rst
+++ b/doc/source/getting_started.rst
@@ -9,7 +9,7 @@ start with the `Parameters as Random Variables`_ section.
 
 Moreover, we also provide an interactive notebook on Binder guiding through the basics of ABC with ABCpy; without
 installing that on your machine.
-Please find if `here <https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples>`_.
+Please find it `here <https://mybinder.org/v2/gh/eth-cscs/abcpy/master?filepath=examples>`_.
 
 Parameters as Random Variables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

From 4c5e15378837942a19b6da1b97d91355809f39cb Mon Sep 17 00:00:00 2001
From: Ritabrata Dutta <statrita2004@gmail.com>
Date: Thu, 5 Nov 2020 20:04:31 +0000
Subject: [PATCH 100/106] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 12bd82c8..f6887566 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ ABCpy for your publication, we would appreciate a citation. You can use
 [this](https://github.com/eth-cscs/abcpy/blob/v0.5.6/doc/literature/DuttaS-ABCpy-PASC-2017.bib) BibTex reference.
 
 
-## Other Refernces
+## Other References
 
 Publications in which ABCpy was applied:
 

From cc355ea437ace5ce27495e77f45165e2a3b9f229 Mon Sep 17 00:00:00 2001
From: Ritabrata Dutta <statrita2004@gmail.com>
Date: Thu, 5 Nov 2020 20:06:35 +0000
Subject: [PATCH 101/106] Update README.md

---
 README.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index f6887566..24676620 100644
--- a/README.md
+++ b/README.md
@@ -92,12 +92,15 @@ ABCpy for your publication, we would appreciate a citation. You can use
 
 Publications in which ABCpy was applied:
 
-* R. Dutta, K. Zouaoui-Boudjeltia, C. Kotsalos, A. Rousseau, D. Ribeiro de Sousa, J. M. Desmet, A. Van Meerhaeghe, A. Mira, and B. Chopard. "Interpretable pathological test for Cardio-vascular disease: Approximate Bayesian computation with distance learning." arXiv preprint arXiv:2010.06465 (2020).
+* R. Dutta, K. Zouaoui-Boudjeltia, C. Kotsalos, A. Rousseau, D. Ribeiro de Sousa, J. M. Desmet, 
+A. Van Meerhaeghe, A. Mira, and B. Chopard. "Interpretable pathological test for Cardio-vascular 
+disease: Approximate Bayesian computation with distance learning.", 2020, arXiv:2010.06465.
 
-* R. Dutta, S. Gomes, D. Kalise, L. Pacchiardi. "Using mobility data in the design of optimal lockdown strategies for the COVID-19 pandemic in England." arXiv preprint arXiv:2006.16059 (2020).
+* R. Dutta, S. Gomes, D. Kalise, L. Pacchiardi. "Using mobility data in the design of optimal 
+lockdown strategies for the COVID-19 pandemic in England.", 2020, arXiv:2006.16059.
 
-* L. Pacchiardi, P. K&#252;nzli, M. Sch&#246;ngens, B. Chopard, R. Dutta, "Distance-Learning for Approximate Bayesian
-  Computation to Model a Volcanic Eruption", 2020, Sankhya B, ISSN 0976-8394, 
+* L. Pacchiardi, P. K&#252;nzli, M. Sch&#246;ngens, B. Chopard, R. Dutta, "Distance-Learning for 
+Approximate Bayesian Computation to Model a Volcanic Eruption", 2020, Sankhya B, ISSN 0976-8394, 
   [DOI: 10.1007/s13571-019-00208-8](https://doi.org/10.1007/s13571-019-00208-8).
 
 * R. Dutta, J. P.  Onnela, A. Mira, "Bayesian Inference of Spreading Processes
@@ -111,11 +114,10 @@ Publications in which ABCpy was applied:
   Computation with High Performance Computing", 2018, Frontiers in physiology, 9.
 
 * A. Ebert, R. Dutta, P. Wu, K. Mengersen and A. Mira, "Likelihood-Free
-  Parameter Estimation for Dynamic Queueing Networks", 2018, arXiv:1804.02526
+  Parameter Estimation for Dynamic Queueing Networks", 2018, arXiv:1804.02526.
 
 * R. Dutta, M. Schoengens, A. Ummadisingu, N. Widerman, J. P.  Onnela, A. Mira, "ABCpy: A
-  High-Performance Computing Perspective to Approximate Bayesian Computation",
-  2017, arXiv:1711.04694
+  High-Performance Computing Perspective to Approximate Bayesian Computation", 2017, arXiv:1711.04694.
 
 ## License
 ABCpy is published under the BSD 3-clause license, see [here](LICENSE).

From 1032918008c8dc249042443593f7c8ba838545b8 Mon Sep 17 00:00:00 2001
From: Ritabrata Dutta <statrita2004@gmail.com>
Date: Thu, 5 Nov 2020 20:08:37 +0000
Subject: [PATCH 102/106] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 24676620..e33a6244 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,7 @@ which however does not work with virtual environments.
 
 # Author 
 ABCpy was written by [Ritabrata Dutta, Warwick
-University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/) and [Marcel Schoengens](mschoengens@bitvalve.org), CSCS, ETH Zurich, and presently actively maintained by [Lorenzo Pacchiardi](https://github.com/LoryPack) and [Ritabrata Dutta, Warwick
+University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/) and [Marcel Schoengens](mschoengens@bitvalve.org), CSCS, ETH Zurich, and presently actively maintained by [Lorenzo Pacchiardi, Oxford University](https://github.com/LoryPack) and [Ritabrata Dutta, Warwick
 University](https://warwick.ac.uk/fac/sci/statistics/staff/academic-research/dutta/). Please feel free to submit any bugs or feature requests. We'd also love to hear about your experiences with ABCpy in general. Drop us an email!
 
 We want to thank [Prof. Antonietta Mira, Università della svizzera

From 6a831f2173a1891fef85bd22d00d036ef44ffaa2 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 6 Nov 2020 11:36:02 +0100
Subject: [PATCH 103/106] Rename notebooks

---
 examples/{getting_started.ipynb => 1_getting_started.ipynb}       | 0
 ...on_ABC_closer_look.ipynb => 2_Rejection_ABC_closer_look.ipynb} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename examples/{getting_started.ipynb => 1_getting_started.ipynb} (100%)
 rename examples/{Rejection_ABC_closer_look.ipynb => 2_Rejection_ABC_closer_look.ipynb} (100%)

diff --git a/examples/getting_started.ipynb b/examples/1_getting_started.ipynb
similarity index 100%
rename from examples/getting_started.ipynb
rename to examples/1_getting_started.ipynb
diff --git a/examples/Rejection_ABC_closer_look.ipynb b/examples/2_Rejection_ABC_closer_look.ipynb
similarity index 100%
rename from examples/Rejection_ABC_closer_look.ipynb
rename to examples/2_Rejection_ABC_closer_look.ipynb

From f292739de62688ad505e8b6346766cabe355d40c Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 6 Nov 2020 13:03:29 +0100
Subject: [PATCH 104/106] Implement Wasserstein Distance; some updates to the
 Distance structure overall.

---
 abcpy/distances.py                | 293 +++++++++++++++++++-----------
 doc/source/class-diagram.png      | Bin 242439 -> 551215 bytes
 doc/source/user_customization.rst |  17 +-
 tests/distances_tests.py          |  29 ++-
 4 files changed, 221 insertions(+), 118 deletions(-)

diff --git a/abcpy/distances.py b/abcpy/distances.py
index 96b3bc78..92cc1418 100644
--- a/abcpy/distances.py
+++ b/abcpy/distances.py
@@ -4,30 +4,42 @@
 from glmnet import LogitNet
 from sklearn import linear_model
 
+from abcpy.utils import wass_dist
+
 
 class Distance(metaclass=ABCMeta):
     """This abstract base class defines how the distance between the observed and
     simulated data should be implemented.
     """
 
-    @abstractmethod
     def __init__(self, statistics_calc):
         """The constructor of a sub-class must accept a non-optional statistics
-        calculator as a parameter. If stored to self.statistics_calc, the
-        private helper method _calculate_summary_stat can be used.
+        calculator as a parameter; then, it must call the __init__ method of the parent class. This ensures that the
+        object is initialized correctly so that the _calculate_summary_stat private method can be called when computing
+        the distances.
 
         Parameters
         ----------
-        statistics_calc : abcpy.stasistics.Statistics
+        statistics_calc : abcpy.statistics.Statistics
             Statistics extractor object that conforms to the Statistics class.
         """
 
-        raise NotImplementedError
+        self.statistics_calc = statistics_calc
+
+        # Since the observations do always stay the same, we can save the
+        #  summary statistics of them and not recalculate it each time
+        self.s1 = None
+        self.data_set = None
+        self.dataSame = False
 
     @abstractmethod
-    def distance(d1, d2):
+    def distance(self, d1, d2):
         """To be overwritten by any sub-class: should calculate the distance between two
         sets of data d1 and d2 using their respective statistics.
+        
+        Usually, calling the _calculate_summary_stat private method to obtain statistics from the datasets is handy;
+        that also keeps track of the first provided dataset (which is the observation in ABCpy inference schemes) and
+        avoids computing the statistics for that multiple times.
 
         Notes
         -----
@@ -38,8 +50,9 @@ def distance(d1, d2):
         1. Transform both input sets dX = [ dX1, dX2, ..., dXn ] to sX = [sX1, sX2,
         ..., sXn] using the statistics object. See _calculate_summary_stat method.
 
-        2. Calculate the mutual desired distance, here denoted by -, between the
-        statistics dist = [s11 - s21, s12 - s22, ..., s1n - s2n].
+        2. Calculate the mutual desired distance, here denoted by - between the
+        statistics; for instance, dist = [s11 - s21, s12 - s22, ..., s1n - s2n] (in some cases however you
+        may want to compute all pairwise distances between statistics elements.
 
         Important: any sub-class must not calculate the distance between data sets
         d1 and d2 directly. This is the reason why any sub-class must be
@@ -54,7 +67,7 @@ def distance(d1, d2):
 
         Returns
         -------
-        numpy.ndarray
+        numpy.float
             The distance between the two input data sets.
         """
 
@@ -79,51 +92,22 @@ def dist_max(self):
 
     def _calculate_summary_stat(self, d1, d2):
         """Helper function that extracts the summary statistics s1 and s2 from d1 and
-        d2 using the statistics object stored in self.statistics_calc.
+        d2 using the statistics object stored in self.statistics_calc. This stores s1 for the purpose of checking
+        whether that is repeated in next calls to the function, and avoiding computing the statitistics for the same
+        dataset several times.
 
         Parameters
         ----------
         d1 : array-like
             d1 contains n data sets.
         d2 : array-like
-            d2 contains n data sets.
+            d2 contains m data sets.
 
         Returns
         -------
-        numpy.ndarray
-            The summary statistics extracted from d1 and d2.
-
-        """
-        s1 = self.statistics_calc.statistics(d1)
-        s2 = self.statistics_calc.statistics(d2)
-        return (s1, s2)
-
-
-class Euclidean(Distance):
-    """
-    This class implements the Euclidean distance between two vectors.
-
-    The maximum value of the distance is np.inf.
-    """
-
-    def __init__(self, statistics):
-        self.statistics_calc = statistics
-
-        # Since the observations do always stay the same, we can save the
-        #  summary statistics of them and not recalculate it each time
-        self.s1 = None
-        self.data_set = None
-        self.dataSame = False
-
-    def distance(self, d1, d2):
-        """Calculates the distance between two datasets.
-
-        Parameters
-        ----------
-        d1, d2: list
-            A list, containing a list describing the data set
+        tuple
+            Tuple containing numpy.ndarray's with the summary statistics extracted from d1 and d2.
         """
-
         if not isinstance(d1, list):
             raise TypeError('Data is not of allowed types')
         if not isinstance(d2, list):
@@ -146,21 +130,64 @@ def distance(self, d1, d2):
 
         s2 = self.statistics_calc.statistics(d2)
 
+        return self.s1, s2
+
+
+class Euclidean(Distance):
+    """
+    This class implements the Euclidean distance between two vectors.
+
+    The maximum value of the distance is np.inf.
+    """
+
+    def __init__(self, statistics):
+        """
+        Parameters
+        ----------
+        statistics_calc : abcpy.statistics.Statistics
+            Statistics extractor object that conforms to the Statistics class.
+        """
+        super(Euclidean, self).__init__(statistics)
+
+    def distance(self, d1, d2):
+        """Calculates the distance between two datasets, by computing Euclidean distance between each element of d1 and
+        d2 and taking their average.
+
+        Parameters
+        ----------
+        d1: Python list
+            Contains n1 data points.
+        d2: Python list
+            Contains n2 data points.
+
+        Returns
+        -------
+        numpy.float
+            The distance between the two input data sets.
+        """
+        s1, s2 = self._calculate_summary_stat(d1, d2)
+
         # compute distance between the statistics
-        dist = np.zeros(shape=(self.s1.shape[0], s2.shape[0]))
-        for ind1 in range(0, self.s1.shape[0]):
+        dist = np.zeros(shape=(s1.shape[0], s2.shape[0]))
+        for ind1 in range(0, s1.shape[0]):
             for ind2 in range(0, s2.shape[0]):
-                dist[ind1, ind2] = np.sqrt(np.sum(pow(self.s1[ind1, :] - s2[ind2, :], 2)))
+                dist[ind1, ind2] = np.sqrt(np.sum(pow(s1[ind1, :] - s2[ind2, :], 2)))
 
         return dist.mean()
 
     def dist_max(self):
+        """
+        Returns
+        -------
+        numpy.float
+            The maximal possible value of the desired distance function.
+        """
         return np.inf
 
 
 class PenLogReg(Distance):
     """
-    This class implements a distance mesure based on the classification accuracy.
+    This class implements a distance measure based on the classification accuracy.
 
     The classification accuracy is calculated between two dataset d1 and d2 using
     lasso penalized logistics regression and return it as a distance. The lasso
@@ -178,12 +205,14 @@ class PenLogReg(Distance):
     """
 
     def __init__(self, statistics):
-        self.statistics_calc = statistics
+        """
+        Parameters
+        ----------
+        statistics_calc : abcpy.statistics.Statistics
+            Statistics extractor object that conforms to the Statistics class.
+        """
+        super(PenLogReg, self).__init__(statistics)
 
-        # Since the observations do always stay the same, we can save the summary statistics of them and not recalculate it each time
-        self.s1 = None
-        self.data_set = None
-        self.dataSame = False
         self.n_folds = 10  # for cross validation in PenLogReg
 
     def distance(self, d1, d2):
@@ -191,30 +220,18 @@ def distance(self, d1, d2):
 
         Parameters
         ----------
-        d1, d2: list
-            A list, containing a list describing the data set
-        """
-        if not isinstance(d1, list):
-            raise TypeError('Data is not of allowed types')
-        if not isinstance(d2, list):
-            raise TypeError('Data is not of allowed types')
-
-        # Check whether d1 is same as self.data_set
-        if self.data_set is not None:
-            # check that the the observations have the same length; if not, they can't be the same:
-            if len(d1) != len(self.data_set):
-                self.dataSame = False
-            elif len(np.array(d1[0]).reshape(-1, )) == 1:
-                self.dataSame = self.data_set == d1
-            else:
-                self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
+        d1: Python list
+            Contains n1 data points.
+        d2: Python list
+            Contains n2 data points.
 
-        # Extract summary statistics from the dataset
-        if self.s1 is None or self.dataSame is False:
-            self.s1 = self.statistics_calc.statistics(d1)
-            self.data_set = d1
-            self.n_simulate = self.s1.shape[0]
-        s2 = self.statistics_calc.statistics(d2)
+        Returns
+        -------
+        numpy.float
+            The distance between the two input data sets.
+        """
+        s1, s2 = self._calculate_summary_stat(d1, d2)
+        self.n_simulate = s1.shape[0]
 
         if not s2.shape[0] == self.n_simulate:
             raise RuntimeError("The number of simulations in the two data sets should be the same in order for "
@@ -223,8 +240,8 @@ def distance(self, d1, d2):
                                "the number of datasets in the observations.")
 
         # compute distance between the statistics
-        training_set_features = np.concatenate((self.s1, s2), axis=0)
-        label_s1 = np.zeros(shape=(len(self.s1), 1))
+        training_set_features = np.concatenate((s1, s2), axis=0)
+        label_s1 = np.zeros(shape=(len(s1), 1))
         label_s2 = np.ones(shape=(len(s2), 1))
         training_set_labels = np.concatenate((label_s1, label_s2), axis=0).ravel()
 
@@ -238,6 +255,12 @@ def distance(self, d1, d2):
         return distance
 
     def dist_max(self):
+        """
+        Returns
+        -------
+        numpy.float
+            The maximal possible value of the desired distance function.
+        """
         return 1.0
 
 
@@ -251,12 +274,17 @@ class LogReg(Distance):
     """
 
     def __init__(self, statistics, seed=None):
-        self.statistics_calc = statistics
+        """
+        Parameters
+        ----------
+        statistics_calc : abcpy.statistics.Statistics
+            Statistics extractor object that conforms to the Statistics class.
+        seed : integer, optionl
+            Seed used to initialize the Random Numbers Generator used to determine the (random) cross validation split
+            in the Logistic Regression classifier.
+        """
 
-        # Since the observations do always stay the same, we can save the summary statistics of them and not recalculate it each time
-        self.s1 = None
-        self.data_set = None
-        self.dataSame = False
+        super(LogReg, self).__init__(statistics)
         # seed is used for a RandomState for the random split in the LogisticRegression classifier:
         self.rng = np.random.RandomState(seed=seed)
 
@@ -265,34 +293,22 @@ def distance(self, d1, d2):
 
         Parameters
         ----------
-        d1, d2: list
-            A list, containing a list describing the data set
-        """
+        d1: Python list
+            Contains n1 data points.
+        d2: Python list
+            Contains n2 data points.
 
-        if not isinstance(d1, list):
-            raise TypeError('Data is not of allowed types')
-        if not isinstance(d2, list):
-            raise TypeError('Data is not of allowed types')
+        Returns
+        -------
+        numpy.float
+            The distance between the two input data sets.
+        """
 
-        # Check whether d1 is same as self.data_set
-        if self.data_set is not None:
-            # check that the the observations have the same length; if not, they can't be the same:
-            if len(d1) != len(self.data_set):
-                self.dataSame = False
-            elif len(np.array(d1[0]).reshape(-1, )) == 1:
-                self.dataSame = self.data_set == d1
-            else:
-                self.dataSame = all([(np.array(self.data_set[i]) == np.array(d1[i])).all() for i in range(len(d1))])
-
-        # Extract summary statistics from the dataset
-        if self.s1 is None or self.dataSame is False:
-            self.s1 = self.statistics_calc.statistics(d1)
-            self.data_set = d1
-        s2 = self.statistics_calc.statistics(d2)
+        s1, s2 = self._calculate_summary_stat(d1, d2)
 
         # compute distance between the statistics
-        training_set_features = np.concatenate((self.s1, s2), axis=0)
-        label_s1 = np.zeros(shape=(len(self.s1), 1))
+        training_set_features = np.concatenate((s1, s2), axis=0)
+        label_s1 = np.zeros(shape=(len(s1), 1))
         label_s2 = np.ones(shape=(len(s2), 1))
         training_set_labels = np.concatenate((label_s1, label_s2), axis=0).ravel()
 
@@ -305,4 +321,67 @@ def distance(self, d1, d2):
         return distance
 
     def dist_max(self):
+        """
+        Returns
+        -------
+        numpy.float
+            The maximal possible value of the desired distance function.
+        """
         return 1.0
+
+
+class Wasserstein(Distance):
+    """This class implements a distance measure based on the 2-Wasserstein distance, as used in [1]. This considers the 
+    several simulations/observations in the datasets as iid samples from the model for a fixed parameter value/from the 
+    data generating model, and computes the 2-Wasserstein distance between the empirical distributions those 
+    simulations/observations define.  
+
+    [1] Bernton, E., Jacob, P.E., Gerber, M. and Robert, C.P. (2019), Approximate Bayesian computation with the
+    Wasserstein distance. J. R. Stat. Soc. B, 81: 235-269. doi:10.1111/rssb.12312
+    """
+
+    def __init__(self, statistics, num_iter_max=100000):
+        """
+        Parameters
+        ----------
+        statistics_calc : abcpy.statistics.Statistics
+            Statistics extractor object that conforms to the Statistics class.
+        num_iter_max : integer, optional
+            The maximum number of iterations in the linear programming algorithm to estimate the Wasserstein distance.
+            Default to 100000.
+        """
+
+        super(Wasserstein, self).__init__(statistics)
+
+        self.num_iter_max = num_iter_max
+
+    def distance(self, d1, d2):
+        """Calculates the distance between two datasets.
+        
+        Parameters
+        ----------
+        d1: Python list
+            Contains n1 data points.
+        d2: Python list
+            Contains n2 data points.
+
+        Returns
+        -------
+        numpy.float
+            The distance between the two input data sets.
+        """
+        s1, s2 = self._calculate_summary_stat(d1, d2)
+
+        # compute the Wasserstein distance between the empirical distributions:
+        return wass_dist(samples_1=s1, samples_2=s2, num_iter_max=self.num_iter_max)
+
+    def dist_max(self):
+        """
+        Returns
+        -------
+        numpy.float
+            The maximal possible value of the desired distance function.
+        """
+
+        # As the statistics are positive, the max possible value is 1
+        return np.inf
diff --git a/doc/source/class-diagram.png b/doc/source/class-diagram.png
index d5bc304a62c032637b3f803b4a50c0037b1047d1..767fbff9718f804c0c56743ebac2eaba44113063 100644
GIT binary patch
literal 551215
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
AYXATM

literal 242439
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
X?RXe(ocK3^0SG)@{an^LB{Ts5h?;G%

diff --git a/doc/source/user_customization.rst b/doc/source/user_customization.rst
index b8f00b86..20636321 100644
--- a/doc/source/user_customization.rst
+++ b/doc/source/user_customization.rst
@@ -389,7 +389,7 @@ compilation commands is also provided.
 Implementing a new Distance
 ---------------------------
 We will now explain how you can implement your own distance measure. A new distance is implemented as a new class that
-derives from :py:class`Distance <abcpy.distance.Distance>` and for which the following three methods have to be
+derives from :py:class:`Distance <abcpy.distances.Distance>` and for which the following three methods have to be
 implemented:
 
 * :py:meth:`Distance.__init__() <abcpy.distances.Distance.__init__>`
@@ -407,26 +407,23 @@ calculator should be provided. The following header conforms to this idea:
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 109-116
+    :lines: 15,27-33
     :dedent: 4
 
-Then, we need to define how the distance is calculated. First we compute the summary statistics from the datasets and
-then compute the distance between the summary statistics. Notice, while computing the summary statistics we save the
-first dataset and the corresponding summary statistics. This is since we always pass the observed dataset first to the
-distance function. The observed dataset does not change during an inference computation and thus it is efficient to
-compute it once and store it internally. (Notice, here the first input data is considered to be the observed data. Hence, 
-to save computation time of summary statistics from observed data, we save the summary from the observed data ad reuse them.)
+Then, we need to define how the distance is calculated. We need first to compute the summary statistics from the datasets and after compute the distance between the summary statistics. Notice that we use the private method :py:meth:`Distance._calculate_summary_stat <abcpy.distances.Distance._calculate_summary_stat>` to compute the statistics from the dataset; internally, this saves the first dataset and the corresponding summary statistics while computing the summary statistics. In fact, we always pass the observed dataset first to the
+distance function during inference and ,as this does not change, it is efficient to
+compute it once and store it internally. At each call of the ``distance`` method, the first input is compared to the stored one and, only if they differ, the stored statistics is updated.
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 118-155
+    :lines: 152-176
     :dedent: 4
 
 Finally, we need to define the maximal distance that can be obtained from this distance measure. 
 
 .. literalinclude:: ../../abcpy/distances.py
     :language: python
-    :lines: 157-158
+    :lines: 178-185
     :dedent: 4
 
 The newly defined distance class can be used in the same way as the already existing once. The complete example for this
diff --git a/tests/distances_tests.py b/tests/distances_tests.py
index 8121f568..349d25a6 100644
--- a/tests/distances_tests.py
+++ b/tests/distances_tests.py
@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from abcpy.distances import Euclidean, PenLogReg, LogReg
+from abcpy.distances import Euclidean, PenLogReg, LogReg, Wasserstein
 from abcpy.statistics import Identity
 
 
@@ -94,5 +94,32 @@ def test_dist_max(self):
         self.assertTrue(self.distancefunc.dist_max() == 1.0)
 
 
+class WassersteinTests(unittest.TestCase):
+    def setUp(self):
+        self.stat_calc = Identity(degree=2, cross=False)
+        self.distancefunc = Wasserstein(self.stat_calc)
+        self.rng = np.random.RandomState(1)
+
+    def test_distance(self):
+        d1 = 0.5 * self.rng.randn(100, 2) - 10
+        d2 = 0.5 * self.rng.randn(100, 2) + 10
+
+        d1 = d1.tolist()
+        d2 = d2.tolist()
+
+        # Checks whether wrong input type produces error message
+        self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
+        self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
+
+        # completely separable datasets should have a distance of 1.0
+        self.assertEqual(self.distancefunc.distance(d1, d2), 28.623685155319652)
+
+        # equal data sets should have a distance of approximately 0.0; it won't be exactly 0 due to numerical rounding
+        self.assertAlmostEqual(self.distancefunc.distance(d1, d1), 0.0, delta=1e-5)
+
+    def test_dist_max(self):
+        self.assertTrue(self.distancefunc.dist_max() == np.inf)
+
+
 if __name__ == '__main__':
     unittest.main()

From c5a4ef13ca9e2fe5cb5f5382c3558d2490745827 Mon Sep 17 00:00:00 2001
From: LoryPack <lorenzo.pacchiardi@stats.ox.ac.uk>
Date: Fri, 6 Nov 2020 14:45:32 +0100
Subject: [PATCH 105/106] Add line in MANIFEST.in

---
 MANIFEST.in | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/MANIFEST.in b/MANIFEST.in
index 540b7204..bcf94c43 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1 +1,2 @@
-include requirements.txt
\ No newline at end of file
+include requirements.txt
+include requirements/*

From 3f8347e2faf385b610e7c25ab7a0f849afd523e5 Mon Sep 17 00:00:00 2001
From: statrita2004 <statrita2004@gmail.com>
Date: Fri, 6 Nov 2020 15:55:01 +0000
Subject: [PATCH 106/106] Preparing for release v0.6.0

---
 README.md              | 6 +++---
 doc/source/DEVELOP.rst | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index e33a6244..a7d9cfb8 100644
--- a/README.md
+++ b/README.md
@@ -26,9 +26,9 @@ scientists by providing
 # Documentation
 For more information, check out the
 
-* [Documentation](http://abcpy.readthedocs.io/en/v0.5.6) 
-* [Examples](https://github.com/eth-cscs/abcpy/tree/v0.5.6/examples) directory and
-* [Reference](http://abcpy.readthedocs.io/en/v0.5.6/abcpy.html)
+* [Documentation](http://abcpy.readthedocs.io/en/v0.6.0) 
+* [Examples](https://github.com/eth-cscs/abcpy/tree/v0.6.0/examples) directory and
+* [Reference](http://abcpy.readthedocs.io/en/v0.6.0/abcpy.html)
 
 
 Further, we provide a
diff --git a/doc/source/DEVELOP.rst b/doc/source/DEVELOP.rst
index 57afac1a..3dd19718 100644
--- a/doc/source/DEVELOP.rst
+++ b/doc/source/DEVELOP.rst
@@ -15,7 +15,7 @@ new version `M.m.b':
 1. Create a release branch `release-M.m.b`
 2. Adapt `VERSION` file in the repos root directory: `echo M.m.b > VERSION`
 3. Adapt `README.md` file: adapt links to correct version of `User Documentation` and `Reference`
-4. Adapt `doc/source/DEVELOP.rst` file: to install correct version of ABCpy
+4. Adapt `doc/source/installation.rst` file: to install correct version of ABCpy
 5. Merge all desired feature branches into the release branch
 6. Create a pull/ merge request: release branch -> master