From f6b527215a41ee01db66cb39f7aa736d36f3d7a6 Mon Sep 17 00:00:00 2001 From: Ritabrata Dutta Date: Fri, 9 Apr 2021 16:05:00 +0100 Subject: [PATCH 01/34] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index fe375d9..21176fd 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ scientists by providing # Documentation For more information, check out the -* [Documentation](http://abcpy.readthedocs.io/en/v0.6.2) +* [Documentation](http://abcpy.readthedocs.io/en/latest) * [Examples](https://github.com/eth-cscs/abcpy/tree/v0.6.2/examples) directory and * [Reference](http://abcpy.readthedocs.io/en/v0.6.2/abcpy.html) From 4b5f70b8c1fbd4a05659ff2bc4422df5f6ce29a4 Mon Sep 17 00:00:00 2001 From: LoryPack Date: Wed, 12 May 2021 15:21:36 +0200 Subject: [PATCH 02/34] Fix shape of parameters in MCMC with initialization --- abcpy/inferences.py | 4 ++++ tests/inferences_tests.py | 27 +++++++++++++++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index 922b1ca..c620573 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -3998,6 +3998,10 @@ def sample(self, observations, n_samples, n_samples_per_param=100, burnin=1000, accepted_parameter = self.get_parameters() else: accepted_parameter = iniPoint + if isinstance(accepted_parameter, np.ndarray) and len(accepted_parameter.shape) == 1 or isinstance( + accepted_parameter, list) and not hasattr(accepted_parameter[0], "__len__"): + # reshape whether we pass a 1d array or list. + accepted_parameter = [np.array([x]) for x in accepted_parameter] # give correct shape for later if burnin == 0: accepted_parameters_burnin.append(accepted_parameter) self.logger.info("Calculate approximate loglikelihood") diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py index da824ae..bbdc3bc 100644 --- a/tests/inferences_tests.py +++ b/tests/inferences_tests.py @@ -220,6 +220,33 @@ def test_sample(self): self.assertAlmostEqual(sigma_post_mean_1, 5.751158868437219) self.assertAlmostEqual(sigma_post_mean_2, 8.103358539327967) + def test_sample_with_inipoint(self): + # we check whether we can compute the posterior covariance, which means the right reshaping of inipoint is used. + + n_sample, n_samples_per_param = 50, 20 + + sampler = MCMCMetropoliHastings([self.model], [self.likfun], self.backend, seed=1) + journal1 = sampler.sample([self.y_obs], n_sample, n_samples_per_param, cov_matrices=None, + iniPoint=np.array([-0.8, 7]), burnin=10, adapt_proposal_cov_interval=5, + use_tqdm=False, path_to_save_journal="tmp.jnl") + + journal2 = sampler.sample([self.y_obs], n_sample, n_samples_per_param, cov_matrices=None, + iniPoint=np.array([np.array([-0.8]), np.array([7])]), burnin=10, + adapt_proposal_cov_interval=5, use_tqdm=False, path_to_save_journal="tmp.jnl") + + journal3 = sampler.sample([self.y_obs], n_sample, n_samples_per_param, cov_matrices=None, + iniPoint=[-0.8, 7], burnin=10, adapt_proposal_cov_interval=5, use_tqdm=False, + path_to_save_journal="tmp.jnl") + + journal4 = sampler.sample([self.y_obs], n_sample, n_samples_per_param, cov_matrices=None, + iniPoint=[np.array([-0.8]), np.array([7])], burnin=10, adapt_proposal_cov_interval=5, + use_tqdm=False, path_to_save_journal="tmp.jnl") + + cov1 = journal1.posterior_cov() + cov2 = journal2.posterior_cov() + cov3 = journal3.posterior_cov() + cov4 = journal3.posterior_cov() + def test_sample_with_transformer(self): n_sample, n_samples_per_param = 50, 20 From 95796ec3c9cf9f82e64692ca2913fbf23280f1e1 Mon Sep 17 00:00:00 2001 From: LoryPack Date: Wed, 12 May 2021 15:34:30 +0200 Subject: [PATCH 03/34] Add link to youtube video in README --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 21176fd..bc51c8d 100644 --- a/README.md +++ b/README.md @@ -61,6 +61,7 @@ For more information, check out the * [Documentation](http://abcpy.readthedocs.io/en/latest) * [Examples](https://github.com/eth-cscs/abcpy/tree/v0.6.2/examples) directory and * [Reference](http://abcpy.readthedocs.io/en/v0.6.2/abcpy.html) +* [Youtube video](https://www.youtube.com/watch?v=cf2uNo0UEBs) presenting the library Further, we provide a From 924176d60e6b6f683ddf4f04ac3de32ac5f755bf Mon Sep 17 00:00:00 2001 From: LoryPack Date: Wed, 26 May 2021 15:55:44 +0200 Subject: [PATCH 04/34] Add method to plot losses after training NNs --- abcpy/NN_utilities/algorithms.py | 12 ++++---- abcpy/NN_utilities/trainer.py | 18 ++++++++--- abcpy/statisticslearning.py | 51 ++++++++++++++++++++++++++----- tests/statisticslearning_tests.py | 42 ++++++++++++++++++++----- 4 files changed, 98 insertions(+), 25 deletions(-) diff --git a/abcpy/NN_utilities/algorithms.py b/abcpy/NN_utilities/algorithms.py index 4a17b0e..14ded15 100644 --- a/abcpy/NN_utilities/algorithms.py +++ b/abcpy/NN_utilities/algorithms.py @@ -81,13 +81,13 @@ 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, + train_losses, test_losses = 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, use_tqdm=use_tqdm) - return embedding_net + return embedding_net, train_losses, test_losses def triplet_training(samples, similarity_set, embedding_net, cuda, batch_size=16, n_epochs=400, @@ -155,12 +155,12 @@ 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, + train_losses, test_losses = 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, use_tqdm=use_tqdm) - return embedding_net + return embedding_net, train_losses, test_losses def FP_nn_training(samples, target, embedding_net, cuda, batch_size=1, n_epochs=50, samples_val=None, target_val=None, @@ -222,9 +222,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, + train_losses, test_losses = 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, use_tqdm=use_tqdm) - return embedding_net + return embedding_net, train_losses, test_losses diff --git a/abcpy/NN_utilities/trainer.py b/abcpy/NN_utilities/trainer.py index 12382ef..18fd337 100644 --- a/abcpy/NN_utilities/trainer.py +++ b/abcpy/NN_utilities/trainer.py @@ -17,8 +17,13 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_ """ logger = logging.getLogger("NN Trainer") - if early_stopping and val_loader is not None: - validation_loss_list = [] + train_loss_list = [] + if val_loader is not None: + test_loss_list = [] + if early_stopping: + early_stopping_loss_list = [] # list of losses used for early stopping + else: + test_loss_list = None 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") @@ -29,22 +34,24 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_ for epoch in tqdm(range(start_epoch_training, n_epochs), disable=not use_tqdm): # Train stage train_loss = train_epoch(train_loader, model, loss_fn, optimizer, cuda) + train_loss_list.append(train_loss) 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) + test_loss_list.append(val_loss) 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 + early_stopping_loss_list.append(val_loss) # save the previous validation loss. It is actually # 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]: + if epoch + 1 >= start_epoch_early_stopping and len(early_stopping_loss_list) > 1: + if early_stopping_loss_list[-1] > early_stopping_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) @@ -54,6 +61,7 @@ def fit(train_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, val_ scheduler.step() + return train_loss_list, test_loss_list def train_epoch(train_loader, model, loss_fn, optimizer, cuda): """Function implementing the training in one epoch. diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index f667253..32a7695 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -1,7 +1,7 @@ import logging from abc import ABCMeta, abstractmethod -import numpy as np +import matplotlib.pyplot as plt from sklearn import linear_model from sklearn.preprocessing import MinMaxScaler @@ -440,13 +440,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, similarity_set, embedding_net=self.embedding_net, - cuda=cuda, samples_val=simulations_val, use_tqdm=use_tqdm, - similarity_set_val=similarity_set_val, **training_routine_kwargs) + self.embedding_net, self.train_losses, self.test_losses = training_routine( + simulations, similarity_set, embedding_net=self.embedding_net, cuda=cuda, samples_val=simulations_val, + use_tqdm=use_tqdm, similarity_set_val=similarity_set_val, **training_routine_kwargs) else: - self.embedding_net = training_routine(simulations, target, embedding_net=self.embedding_net, - cuda=cuda, samples_val=simulations_val, target_val=target_val, - use_tqdm=use_tqdm, **training_routine_kwargs) + self.embedding_net, self.train_losses, self.test_losses = training_routine( + simulations, target, embedding_net=self.embedding_net, cuda=cuda, samples_val=simulations_val, + target_val=target_val, use_tqdm=use_tqdm, **training_routine_kwargs) self.logger.info("Finished learning the transformation.") @@ -471,6 +471,43 @@ def get_statistics(self): else: return NeuralEmbedding(net=self.embedding_net, previous_statistics=self.statistics_calc) + def plot_losses(self, which_losses="both"): + """ + Plot losses vs training epochs after the NN have been trained. + + Parameters + ---------- + which_losses: string, optional + Specifies which set of losses to display (between training and test loss). + Can be "train", "test" or "both". Notice that the test loss could be unavailable (in case no test set was + used for training), in which case the test loss is not shown even if requested. Defaults to "both". + + Returns + ------- + + """ + + if which_losses not in ["both", "train", "test"]: + raise NotImplementedError("'which_losses' should be 'both', 'train' or 'test'") + + fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4)) + if which_losses in ["both", "train"]: + ax.plot(np.arange(len(self.train_losses)) + 1, self.train_losses, label="Train loss", color="C0") + if which_losses in ["both", "test"]: + if self.test_losses is not None: + if len(self.test_losses) != len(self.train_losses): + raise RuntimeError("Length of train and test losses list should be the same.") + ax.plot(np.arange(len(self.train_losses)) + 1, self.test_losses, label="Test loss", color="C1") + else: + self.logger.warning("You requested to plot test losses, but these are unavailable (probably due to no " + "test set been used during NN training.") + + ax.set_xlabel("Training epoch") + ax.set_ylabel("Loss") + ax.legend() + + return fig, ax + # the following classes subclass the base class StatisticsLearningNN with different training routines diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py index 8247bd4..072c2c3 100644 --- a/tests/statisticslearning_tests.py +++ b/tests/statisticslearning_tests.py @@ -65,8 +65,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, scale_samples=False, - use_tqdm=False) + n_samples_val=100, n_samples_per_param=1, seed=1, n_epochs=10, + scale_samples=False, use_tqdm=False) + self.statisticslearning2 = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=10, + n_samples_val=10, n_samples_per_param=1, seed=1, n_epochs=5, + scale_samples=False, use_tqdm=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, @@ -146,6 +149,17 @@ def test_errors(self): n_samples_per_param=1, seed=1, parameters_val=[i for i in range(10)], simulations_val=[i for i in range(10)]) + with self.assertRaises(RuntimeError): + self.statisticslearning2.test_losses = [4, 2, 1] + self.statisticslearning2.plot_losses() + with self.assertRaises(NotImplementedError): + self.statisticslearning.plot_losses(which_losses="foo") + + def test_plots(self): + if has_torch: + self.statisticslearning.plot_losses() + self.statisticslearning.plot_losses(which_losses="train") + self.statisticslearning.plot_losses(which_losses="test") class ContrastiveDistanceLearningTests(unittest.TestCase): @@ -164,13 +178,15 @@ def setUp(self): if has_torch: # 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, scale_samples=False, use_tqdm=False) + n_samples=100, n_samples_val=100, + n_samples_per_param=1, seed=1, n_epochs=10, + scale_samples=False, use_tqdm=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, use_tqdm=False) + n_epochs=10, scale_samples=True, + use_tqdm=False) def test_initialization(self): if not has_torch: @@ -196,6 +212,12 @@ def test_transformation(self): self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) + def test_plots(self): + if has_torch: + self.statisticslearning.plot_losses() + self.statisticslearning.plot_losses(which_losses="train") + self.statisticslearning.plot_losses(which_losses="test") + class TripletDistanceLearningTests(unittest.TestCase): def setUp(self): @@ -213,8 +235,8 @@ def setUp(self): if has_torch: # Initialize statistics learning self.statisticslearning = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend, - scale_samples=False, use_tqdm=False, - n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10) + n_samples=100, n_samples_val=100, n_samples_per_param=1, + seed=1, n_epochs=10, scale_samples=False, use_tqdm=False) # with sample scaler: self.statisticslearning_with_scaler = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend, scale_samples=True, use_tqdm=False, @@ -244,6 +266,12 @@ def test_transformation(self): self.assertRaises(ValueError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) + def test_plots(self): + if has_torch: + self.statisticslearning.plot_losses() + self.statisticslearning.plot_losses(which_losses="train") + self.statisticslearning.plot_losses(which_losses="test") + if __name__ == '__main__': unittest.main() From f677145bfacf8ebcbcef8610a8695342a96f6f0e Mon Sep 17 00:00:00 2001 From: LoryPack Date: Wed, 16 Jun 2021 18:08:54 +0200 Subject: [PATCH 05/34] Docstring improvements --- abcpy/continuousmodels.py | 5 +++-- abcpy/distances.py | 24 ++++++++++++++++++++---- abcpy/inferences.py | 6 +++--- abcpy/transformers.py | 2 +- 4 files changed, 27 insertions(+), 10 deletions(-) diff --git a/abcpy/continuousmodels.py b/abcpy/continuousmodels.py index b1b6e2b..baa9e98 100644 --- a/abcpy/continuousmodels.py +++ b/abcpy/continuousmodels.py @@ -690,8 +690,9 @@ def __init__(self, parameters, name='Exponential'): ---------- parameters: list Contains the probabilistic models and hyperparameters from which the model derives. - The list has one entry: the rate $\lambda$ of the exponential distribution, that has therefore pdf: - f(x; \lambda) = \lambda \exp(-\lambda x ), + The list has one entry: the rate :math:`\lambda` of the exponential distribution, that has therefore pdf: + :math:`f(x; \lambda) = \lambda \exp(-\lambda x )` + name: string The name that should be given to the probabilistic model in the journal file. """ diff --git a/abcpy/distances.py b/abcpy/distances.py index 9d3b25a..0998374 100644 --- a/abcpy/distances.py +++ b/abcpy/distances.py @@ -482,6 +482,14 @@ def _estimate_always_positive(self): @staticmethod def get_random_projections(n_projections, d, seed=None): r""" + Taken from + + https://github.com/PythonOT/POT/blob/78b44af2434f494c8f9e4c8c91003fbc0e1d4415/ot/sliced.py + + Author: Adrien Corenflos + + License: MIT License + Generates n_projections samples from the uniform on the unit sphere of dimension d-1: :math:`\mathcal{U}(\mathcal{S}^{d-1})` Parameters ---------- @@ -516,11 +524,19 @@ def get_random_projections(n_projections, d, seed=None): def sliced_wasserstein_distance(self, X_s, X_t, a=None, b=None, n_projections=50, seed=None, log=False): r""" + Taken from + + https://github.com/PythonOT/POT/blob/78b44af2434f494c8f9e4c8c91003fbc0e1d4415/ot/sliced.py + + Author: Adrien Corenflos + + License: MIT License + Computes a Monte-Carlo approximation of the 2-Sliced Wasserstein distance - .. math:: - \mathcal{SWD}_2(\mu, \nu) = \underset{\theta \sim \mathcal{U}(\mathbb{S}^{d-1})}{\mathbb{E}}[\mathcal{W}_2^2(\theta_\# \mu, \theta_\# \nu)]^{\frac{1}{2}} - where : - - :math:`\theta_\# \mu` stands for the pushforwars of the projection :math:`\mathbb{R}^d \ni X \mapsto \langle \theta, X \rangle` + :math:`\mathcal{SWD}_2(\mu, \nu) = \underset{\theta \sim \mathcal{U}(\mathbb{S}^{d-1})}{\mathbb{E}}[\mathcal{W}_2^2(\theta_\# \mu, \theta_\# \nu)]^{\frac{1}{2}}` + where + :math:`\theta_\# \mu` stands for the pushforwars of the projection :math:`\mathbb{R}^d \ni X \mapsto \langle \theta, X \rangle` + Parameters ---------- X_s : ndarray, shape (n_samples_a, dim) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index c620573..5dc536f 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -167,7 +167,7 @@ class RejectionABC(InferenceMethod): each model. backend: abcpy.backends.Backend Backend object defining the backend to be used. - seed: integer, optionaldistance + seed: integer, optional Optional initial seed for the random number generator. The default value is generated randomly. """ @@ -411,8 +411,8 @@ def _sample_parameter(self, rng, npc=None): distance = self.distance.dist_max() if distance < self.epsilon and self.logger: - self.logger.warn("initial epsilon {:e} is larger than dist_max {:e}" - .format(float(self.epsilon), distance)) + self.logger.warning("initial epsilon {:e} is larger than dist_max {:e}" + .format(float(self.epsilon), distance)) counter = 0 diff --git a/abcpy/transformers.py b/abcpy/transformers.py index 95ba467..b6b26fc 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -124,7 +124,7 @@ def jac_log_det(self, x): Parameters ---------- x : list of len n_parameters - Input data, living in the original space (with lower bound constraints). + Input data, living in the original space (with bounds). Returns ------- res : float From dbd6fb7122efd33e1bbc845a4c9f635042e810fc Mon Sep 17 00:00:00 2001 From: LoryPack Date: Wed, 16 Jun 2021 18:10:08 +0200 Subject: [PATCH 06/34] Add DrawFromPrior --- abcpy/inferences.py | 240 ++++++++++++++++++++++++++++++++++++++ tests/inferences_tests.py | 72 +++++++++++- 2 files changed, 308 insertions(+), 4 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index c620573..276ae9d 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -151,6 +151,246 @@ def distance(self): raise NotImplementedError +class DrawFromPrior(InferenceMethod): + """Helper class to obtain samples from the prior for a model. + + The `sample` method follows similar API to the other InferenceMethod's (returning a journal file), while the + `sample_par_sim_pairs` method generates (parameter, simulation) pairs, which can be used for instance as a training + dataset for the automatic learning of summary statistics with the StatisticsLearning classes. + + Parameters + ---------- + root_models: list + A list of the Probabilistic models corresponding to the observed datasets + backend: abcpy.backends.Backend + Backend object defining the backend to be used. + seed: integer, optional + Optional initial seed for the random number generator. The default value is generated randomly. + discard_too_large_values: boolean + If set to True, the simulation is discarded (and repeated) if at least one element of it is too large + to fit in float32, which therefore may be converted to infinite value in numpy. Defaults to False. + """ + + model = None + rng = None + n_samples = None + backend = None + + n_samples_per_param = None # this needs to be there otherwise it does not instantiate correctly + + def __init__(self, root_models, backend, seed=None, discard_too_large_values=False): + self.model = root_models + self.backend = backend + self.rng = np.random.RandomState(seed) + self.discard_too_large_values = discard_too_large_values + # An object managing the bds objects + self.accepted_parameters_manager = AcceptedParametersManager(self.model) + self.logger = logging.getLogger(__name__) + + def sample(self, n_samples, path_to_save_journal=None): + """ + Samples model parameters from the prior distribution. + + Parameters + ---------- + n_samples: integer + Number of samples to generate + path_to_save_journal: str, optional + If provided, save the journal after inference at the provided path. + + Returns + ------- + abcpy.output.Journal + a journal containing results and metadata. + """ + + journal = Journal(1) + journal.configuration["type_model"] = [type(model).__name__ for model in self.model] + journal.configuration["n_samples"] = self.n_samples + + # the following lines are similar to the RejectionABC code but only sample from the prior. + # now generate an array of seeds that need to be different one from the other. One way to do it is the + # following. + # Moreover, you cannot use int64 as seeds need to be < 2**32 - 1. How to fix this? + # Note that this is not perfect; you still have small possibility of having some seeds that are equal. Is there + # a better way? This would likely not change much the performance + # An idea would be to use rng.choice but that is too expensive + seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32) + # check how many equal seeds there are and remove them: + sorted_seed_arr = np.sort(seed_arr) + indices = sorted_seed_arr[:-1] == sorted_seed_arr[1:] + if np.sum(indices) > 0: + # the following removes the equal seeds in case there are some + sorted_seed_arr[:-1][indices] = sorted_seed_arr[:-1][indices] + 1 + rng_arr = np.array([np.random.RandomState(seed) for seed in sorted_seed_arr]) + rng_pds = self.backend.parallelize(rng_arr) + + parameters_pds = self.backend.map(self._sample_parameter_only, rng_pds) + parameters = self.backend.collect(parameters_pds) + # accepted_parameters, distances, counter = [list(t) for t in zip(*accepted_parameters_distances_counter)] + + self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=parameters) + journal.add_accepted_parameters(copy.deepcopy(parameters)) + journal.add_weights(np.ones((n_samples, 1))) + journal.add_ESS_estimate(np.ones((n_samples, 1))) + self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=parameters) + names_and_parameters = self._get_names_and_parameters() + journal.add_user_parameters(names_and_parameters) + journal.number_of_simulations.append(0) + + if path_to_save_journal is not None: # save journal + journal.save(path_to_save_journal) + + return journal + + def sample_par_sim_pairs(self, n_samples, n_samples_per_param, max_chunk_size=10 ** 4): + """ + Samples (parameter, simulation) pairs from the prior distribution from the model distribution. Specifically, + parameter values are sampled from the prior and used to generate the specified number of simulations per + parameter value. This returns arrays. + + When generating large datasets with MPI backend, pickling may give overflow error; for this reason, the function + splits the generation in "chunks" of the specified size on which the parallelization is used. + + Parameters + ---------- + n_samples: integer + Number of samples to generate + n_samples_per_param: integer + Number of data points in each simulated data set. + max_chunk_size: integer, optional + Maximum size of chunks in which to split the data generation. Defaults to 10**4 + + Returns + ------- + tuple + A tuple of numpy.ndarray's containing parameter and simulation values. The first element of the tuple is an + array with shape (n_samples, d_theta), where d_theta is the dimension of the parameters. The second element + of the tuple is an array with shape (n_samples, n_samples_per_param, d_x), where d_x is the dimension of + each simulation. + """ + + parameters_list = [] + simulations_list = [] + samples_to_sample = n_samples + while samples_to_sample > 0: + parameters_part, simulations_part = self._sample_par_sim_pairs(min(samples_to_sample, max_chunk_size), + n_samples_per_param) + samples_to_sample -= max_chunk_size + parameters_list.append(parameters_part) + simulations_list.append(simulations_part) + parameters = np.concatenate(parameters_list) + simulations = np.concatenate(simulations_list) + return parameters, simulations + + def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): + """ + Not for end use; please use `sample_par_sim_pairs`. + + Samples (parameter, simulation) pairs from the prior distribution from the model distribution. Specifically, + parameter values are sampled from the prior and used to generate the specified number of simulations per + parameter value. This returns arrays. + + Parameters + ---------- + n_samples: integer + Number of samples to generate + n_samples_per_param: integer + Number of data points in each simulated data set. + max_chunk_size: integer, optional + Maximum size of chunks in which to split the data generation. Defaults to 10**4 + + Returns + ------- + tuple + A tuple of numpy.ndarray's containing parameter and simulation values. The first element of the tuple is an + array with shape (n_samples, d_theta), where d_theta is the dimension of the parameters. The second element + of the tuple is an array with shape (n_samples, n_samples_per_param, d_x), where d_x is the dimension of + each simulation. + """ + self.n_samples = n_samples + self.n_samples_per_param = n_samples_per_param + self.accepted_parameters_manager.broadcast(self.backend, 1) + + # now generate an array of seeds that need to be different one from the other. One way to do it is the + # following. + # Moreover, you cannot use int64 as seeds need to be < 2**32 - 1. How to fix this? + # Note that this is not perfect; you still have small possibility of having some seeds that are equal. Is there + # a better way? This would likely not change much the performance + # An idea would be to use rng.choice but that is too expensive + seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32) + # check how many equal seeds there are and remove them: + sorted_seed_arr = np.sort(seed_arr) + indices = sorted_seed_arr[:-1] == sorted_seed_arr[1:] + if np.sum(indices) > 0: + # the following removes the equal seeds in case there are some + sorted_seed_arr[:-1][indices] = sorted_seed_arr[:-1][indices] + 1 + rng_arr = np.array([np.random.RandomState(seed) for seed in sorted_seed_arr]) + rng_pds = self.backend.parallelize(rng_arr) + + parameters_simulations_pds = self.backend.map(self._sample_parameter_simulation, rng_pds) + parameters_simulations = self.backend.collect(parameters_simulations_pds) + parameters, simulations = [list(t) for t in zip(*parameters_simulations)] + + parameters = np.array(parameters) + simulations = np.array(simulations) + + parameters = parameters.reshape((parameters.shape[0], parameters.shape[1])) + simulations = simulations.reshape((simulations.shape[0], simulations.shape[2], simulations.shape[3],)) + + return parameters, simulations + + def _sample_parameter_simulation(self, rng, npc=None): + """ + Samples a single model parameter and simulates from it. + + Parameters + ---------- + rng: random number generator + The random number generator to be used. + Returns + ------- + Tuple + The first entry of the tuple is the parameter. + The second entry is the the simulation drawn from it. + """ + + ok_flag = False + + while not ok_flag: + 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) + + # if there are no potential infinities there (or if we do not check for those). + # For instance, Lorenz model may give too large values sometimes (quite rarely). + if self.discard_too_large_values and np.sum(np.isinf(np.array(y_sim).astype("float32"))) > 0: + self.logger.warning("y_sim contained too large values for float32; simulating again.") + else: + ok_flag = True + + return theta, y_sim + + def _sample_parameter_only(self, rng, npc=None): + """ + Samples a single model parameter from the prior. + + Parameters + ---------- + rng: random number generator + The random number generator to be used. + Returns + ------- + list + The sampled parameter values + """ + + self.sample_from_prior(rng=rng) + theta = self.get_parameters(self.model) + + return theta + + class RejectionABC(InferenceMethod): """This class implements the rejection algorithm based inference scheme [1] for Approximate Bayesian Computation. diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py index bbdc3bc..acb4d41 100644 --- a/tests/inferences_tests.py +++ b/tests/inferences_tests.py @@ -7,11 +7,78 @@ from abcpy.continuousmodels import Normal from abcpy.continuousmodels import Uniform from abcpy.distances import Euclidean, MMD -from abcpy.inferences import RejectionABC, PMC, PMCABC, SABC, ABCsubsim, SMCABC, APMCABC, RSMCABC, \ +from abcpy.inferences import DrawFromPrior, RejectionABC, PMC, PMCABC, SABC, ABCsubsim, SMCABC, APMCABC, RSMCABC, \ MCMCMetropoliHastings from abcpy.statistics import Identity +class DrawFromPriorTest(unittest.TestCase): + def setUp(self): + # setup backend + dummy = 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]) + + # create fake observed data + self.y_obs = [np.array(9.8)] + + # for correct seeding define 2 samplers (and discard large values in the second to test if that works) + self.sampler = DrawFromPrior([self.model], dummy, seed=1) + self.sampler2 = DrawFromPrior([self.model], dummy, seed=1, discard_too_large_values=True) + + # expected mean values from 100 prior samples: + self.mu_mean = -0.24621316447913139 + self.sigma_mean = 5.182264389159227 + + def test_sample_n_samples(self): + # test drawing parameter values from the prior in a similar fashion to the other InferenceMethdod's + journal = self.sampler.sample(100, path_to_save_journal="tmp.jnl") + mu_sample = np.array(journal.get_parameters()['mu']) + sigma_sample = np.array(journal.get_parameters()['sigma']) + + accepted_parameters = journal.get_accepted_parameters() + self.assertEqual(len(accepted_parameters), 100) + self.assertEqual(len(accepted_parameters[0]), 2) + + # 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, (100, 1)) + self.assertEqual(sigma_shape, (100, 1)) + + # Compute posterior mean + self.assertAlmostEqual(np.average(mu_sample), self.mu_mean) + self.assertAlmostEqual(np.average(sigma_sample), self.sigma_mean) + + self.assertTrue(journal.number_of_simulations[0] == 0) + + def test_param_simulation_pairs(self): + # sample single simulation for each par value + parameters, simulations = self.sampler.sample_par_sim_pairs(10, 1) + self.assertEqual(parameters.shape, (10, 2)) + self.assertEqual(simulations.shape, (10, 1, 1)) + + # sample multiple simulations for each par value + parameters, simulations = self.sampler.sample_par_sim_pairs(10, 3) + self.assertEqual(parameters.shape, (10, 2)) + self.assertEqual(simulations.shape, (10, 3, 1)) + + # try with smaller max_chunk_size + parameters, simulations = self.sampler.sample_par_sim_pairs(10, 3, max_chunk_size=2) + self.assertEqual(parameters.shape, (10, 2)) + self.assertEqual(simulations.shape, (10, 3, 1)) + + # now run with the new sampler to check if the means are the same as with `.sample` method: + parameters, simulations = self.sampler2.sample_par_sim_pairs(100, 1) + means = np.mean(parameters, axis=0) + self.assertAlmostEqual(means[0], self.mu_mean) + self.assertAlmostEqual(means[1], self.sigma_mean) + + class RejectionABCTest(unittest.TestCase): def setUp(self): # setup backend @@ -49,7 +116,6 @@ def test_sample_n_samples(self): 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(mu_sample), 1.223012836345375) self.assertAlmostEqual(np.average(sigma_sample), 6.992218962395242) @@ -68,7 +134,6 @@ def test_sample_simulation_budget(self): self.assertEqual(sigma_shape, (3, 1)) # Compute posterior mean - # self.assertAlmostEqual(np.average(np.asarray(samples[:,0])),1.22301,10e-2) self.assertAlmostEqual(np.average(mu_sample), 0.8175361535037666) self.assertAlmostEqual(np.average(sigma_sample), 8.155647092489977) @@ -86,7 +151,6 @@ def test_sample_simulation_budget(self): 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(mu_sample), 0.10394992719538543) self.assertAlmostEqual(np.average(sigma_sample), 6.746940834914168) From 10b0dbcc218ace60287496ad77fb06bbae966683 Mon Sep 17 00:00:00 2001 From: LoryPack Date: Sun, 4 Jul 2021 18:21:14 +0200 Subject: [PATCH 07/34] Documentation and examples for DrawFromPrior. Also add example on how to use previous generated data to perform statistics learning and how to store and re-load NN fit with statistics learning routines. --- doc/source/getting_started.rst | 22 ++- ...stics_learning_DrawFromPrior_reload_NNs.py | 147 ++++++++++++++++++ tests/test_examples.py | 8 + 3 files changed, 172 insertions(+), 5 deletions(-) create mode 100644 examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst index 392e5a1..c317180 100644 --- a/doc/source/getting_started.rst +++ b/doc/source/getting_started.rst @@ -131,7 +131,7 @@ Note that the model and the observations are given as a list. This is due to the have hierarchical models, building relationships between co-occurring groups of datasets. To learn more, see the `Hierarchical Model`_ section. -The full source can be found in `examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py`. To +The full source can be found in `examples/extensions/models/gaussian_python/pmcabc_gaussian_model_simple.py `_. To execute the code you only need to run :: @@ -249,7 +249,7 @@ different observed data sets respectively. Also notice now we provide two differ different root models and their observed datasets. Presently ABCpy combines the distances by a linear combination, however customized combination strategies can be implemented by the user. -The full source code can be found in `examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py`. +The full source code can be found in `examples/hierarchicalmodels/pmcabc_inference_on_multiple_sets_of_obs.py `_. Composite Perturbation Kernels @@ -280,7 +280,7 @@ you would like to implement your own perturbation kernel, please check :ref:`Imp `. Please keep in mind that you can only perturb parameters. **You cannot use the access operator to perturb one component of a multi-dimensional random variable differently than another component of the same variable.** -The source code to this section can be found in `examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py` +The source code to this section can be found in `examples/extensions/perturbationkernels/pmcabc_perturbation_kernels.py `_. Inference Schemes ~~~~~~~~~~~~~~~~~ @@ -316,6 +316,8 @@ the following methods methods: * Semiparametric Synthetic likelihood :py:class:`abcpy.approx_lhd.SemiParametricSynLikelihood`, and another method using * penalized logistic regression :py:class:`abcpy.approx_lhd.PenLogReg`. +Finally, we also include a utility class with a similar API as the previous inference schemes which allows to sample from the prior: :py:class:`abcpy.inferences.DrawFromPrior`. + Next we explain how we can use PMC algorithm using approximation of the likelihood functions. As we are now considering two observed datasets corresponding to two root models, we need to define an approximation of @@ -341,9 +343,9 @@ different observed data sets respectively. Also notice we now provide two differ different root models and their observed datasets. Presently ABCpy combines the distances by a linear combination. Further possibilities of combination will be made available in later versions of ABCpy. -The source code can be found in `examples/approx_lhd/pmc_hierarchical_models.py`. +The source code can be found in `examples/approx_lhd/pmc_hierarchical_models.py `_. -For an example using MCMC instead of PMC, check out `examples/approx_lhd/mcmc_hierarchical_models.py`. +For an example using MCMC instead of PMC, check out `examples/approx_lhd/mcmc_hierarchical_models.py `_. Statistics Learning ~~~~~~~~~~~~~~~~~~~ @@ -407,6 +409,16 @@ And similarly for the other two approaches. We can then perform the inference as before, but the distances will be computed on the newly learned summary statistics. +The above summary statistics learning routines can also be initialized with previously generated parameter-observation pairs (this can be useful for instance when different statistics learning techniques need to be tested with the same training dataset). The :py:class:`abcpy.inferences.DrawFromPrior` class can be used to generate such training data. We provide an example showcasing this in `examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py `_. + +Finally, when we use a neural network-based summary statistics learning approach, the neural network can be stored to disk and loaded later. This is done in the following chunk of code (taken from an example shipped with code); notice the use of the :py:class:`abcpy.statistics.NeuralEmbedding` Statistics class: + +.. literalinclude:: ../../examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py + :language: python + :lines: 83-84, 86-88, 91-97 + :dedent: 4 + + Model Selection ~~~~~~~~~~~~~~~ diff --git a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py new file mode 100644 index 0000000..c1d4e8b --- /dev/null +++ b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py @@ -0,0 +1,147 @@ +import logging + +import numpy as np + + +def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level=logging.WARN): + """Perform inference for this example. + + Parameters + ---------- + steps : integer, optional + Number of iterations in the sequential PMCABC algorithm ("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 + 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] + + # define prior + from abcpy.continuousmodels import Uniform + mu = Uniform([[150], [200]], name="mu") + sigma = Uniform([[5], [25]], name="sigma") + + # define the model + from abcpy.continuousmodels import Normal + height = Normal([mu, sigma], ) + + # 1) generate simulations from prior + from abcpy.inferences import DrawFromPrior + draw_from_prior = DrawFromPrior([height], backend=backend) + + # notice the use of the `.sample_par_sim_pairs` method rather than `.sample` to obtain data suitably formatted + # for the summary statistics learning routines + parameters, simulations = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) + # if you want to use the test loss to do early stopping in the training: + parameters_val, simulations_val = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) + # discard the mid dimension (n_samples_per_param, as the StatisticsLearning classes use that =1) + simulations = simulations.reshape(simulations.shape[0], simulations.shape[2]) + simulations_val = simulations_val.reshape(simulations_val.shape[0], simulations_val.shape[2]) + + # 2) now train the NNs with the different methods with the generated data + from abcpy.statistics import Identity + identity = Identity() # to apply before computing the statistics + + print("semiNN") + from abcpy.statisticslearning import SemiautomaticNN, TripletDistanceLearning + semiNN = SemiautomaticNN([height], identity, backend=backend, parameters=parameters, + simulations=simulations, parameters_val=parameters_val, simulations_val=simulations, + early_stopping=True, # early stopping + seed=1, n_epochs=10, scale_samples=False) + print("triplet") + triplet = TripletDistanceLearning([height], identity, backend=backend, parameters=parameters, + simulations=simulations, parameters_val=parameters_val, + simulations_val=simulations, + early_stopping=True, # early stopping + seed=1, n_epochs=10, scale_samples=True) + + # 3) save and re-load NNs: + # get the statistics from the already fit StatisticsLearning object 'semiNN': + learned_seminn_stat = semiNN.get_statistics() + learned_triplet_stat = triplet.get_statistics() + + # this has a save net method: + learned_seminn_stat.save_net("seminn_net.pth") + # if you used `scale_samples=True` in learning the NNs, need to provide a path where pickle stores the scaler too: + learned_triplet_stat.save_net("triplet_net.pth", path_to_scaler="scaler.pkl") + + # to reload: need to use the Neural Embedding statistics fromFile; this needs to know which kind of NN it is using; + # need therefore to pass either the input/output size (it data size and number parameters) or the network class if + # that was specified explicitly in the StatisticsLearning class. Check the docstring for NeuralEmbedding.fromFile + # for more details. + from abcpy.statistics import NeuralEmbedding + learned_seminn_stat_loaded = NeuralEmbedding.fromFile("seminn_net.pth", input_size=1, output_size=2) + learned_triplet_stat_loaded = NeuralEmbedding.fromFile("triplet_net.pth", input_size=1, output_size=2, + path_to_scaler="scaler.pkl") + + # 4) perform inference + # define distance + from abcpy.distances import Euclidean + distance_calculator = Euclidean(learned_seminn_stat_loaded) + + # define kernel + from abcpy.perturbationkernel import DefaultKernel + kernel = DefaultKernel([mu, sigma]) + + # define sampling scheme + from abcpy.inferences import PMCABC + sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) + + 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], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) + + return journal + + +def analyse_journal(journal): + # output parameters and weights + print(journal.opt_values) + print(journal.get_weights()) + + # do post analysis + print(journal.posterior_mean()) + print(journal.posterior_cov()) + + # 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') + + +if __name__ == "__main__": + journal = infer_parameters(logging_level=logging.INFO) + analyse_journal(journal) diff --git a/tests/test_examples.py b/tests/test_examples.py index 2fb97d6..6901e8d 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -96,6 +96,14 @@ def test_pmcabc(self): expected_result = 172.52136853079725 self.assertAlmostEqual(test_result, expected_result) + def test_gaussian_statistics_learning_DrawFromPrior_reload_NNs(self): + if has_torch: + from examples.statisticslearning.gaussian_statistics_learning_DrawFromPrior_reload_NNs 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() From b69a59a08000ca1b13a813db1b0dc8e337013f00 Mon Sep 17 00:00:00 2001 From: LoryPack Date: Sun, 4 Jul 2021 18:51:18 +0200 Subject: [PATCH 08/34] Doc fixes --- abcpy/distances.py | 4 +++- abcpy/transformers.py | 14 +++++++++----- doc/source/postanalysis.rst | 8 ++++++++ 3 files changed, 20 insertions(+), 6 deletions(-) diff --git a/abcpy/distances.py b/abcpy/distances.py index 0998374..14a4390 100644 --- a/abcpy/distances.py +++ b/abcpy/distances.py @@ -491,6 +491,7 @@ def get_random_projections(n_projections, d, seed=None): License: MIT License Generates n_projections samples from the uniform on the unit sphere of dimension d-1: :math:`\mathcal{U}(\mathcal{S}^{d-1})` + Parameters ---------- n_projections : int @@ -499,6 +500,7 @@ def get_random_projections(n_projections, d, seed=None): dimension of the space seed: int or RandomState, optional Seed used for numpy random number generator + Returns ------- out: ndarray, shape (n_projections, d) @@ -568,7 +570,7 @@ def sliced_wasserstein_distance(self, X_s, X_t, a=None, b=None, n_projections=50 0.0 References ---------- - .. [31] Bonneel, Nicolas, et al. "Sliced and radon wasserstein barycenters of measures." Journal of Mathematical Imaging and Vision 51.1 (2015): 22-45 + Bonneel, Nicolas, et al. "Sliced and radon wasserstein barycenters of measures." Journal of Mathematical Imaging and Vision 51.1 (2015): 22-45 """ from ot.lp import emd2_1d diff --git a/abcpy/transformers.py b/abcpy/transformers.py index b6b26fc..38f9614 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -70,10 +70,12 @@ def _list_from_array(x_arr, x): def transform(self, x): """Scale features of x according to feature_range. + Parameters ---------- - x : list of len n_parameters + x : list of length n_parameters Input data that will be transformed. + Returns ------- Xt : array-like of shape (n_samples, n_features) @@ -95,10 +97,12 @@ def transform(self, x): def inverse_transform(self, x): """Undo the scaling of x according to feature_range. + Parameters ---------- x : list of len n_parameters Input data that will be transformed. It cannot be sparse. + Returns ------- Xt : array-like of shape (n_samples, n_features) @@ -119,7 +123,7 @@ def inverse_transform(self, x): return inv_x def jac_log_det(self, x): - """Returns the log determinant of the Jacobian: log |J_t(x)|. + """Returns the log determinant of the Jacobian: :math:`\log |J_t(x)|`. Parameters ---------- @@ -144,16 +148,16 @@ def jac_log_det(self, x): def jac_log_det_inverse_transform(self, x): """Returns the log determinant of the Jacobian evaluated in the inverse transform: - log |J_t(t^{-1}(x))| = - log |J_{t^{-1}}(x)| + :math:`\log |J_t(t^{-1}(x))| = - log |J_{t^{-1}}(x)|` Parameters ---------- x : list of len n_parameters - Input data, living in the transformed space (spanning the whole R^d). + Input data, living in the transformed space (spanning the whole :math:`R^d`). Returns ------- res : float - log determinant of the jacobian evaluated in t^{-1}(x) + log determinant of the jacobian evaluated in :math:`t^{-1}(x)` """ x = self._array_from_list(x) diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst index 260cea0..001142d 100644 --- a/doc/source/postanalysis.rst +++ b/doc/source/postanalysis.rst @@ -83,6 +83,14 @@ distributions defined by the samples and weights at subsequent iterations: journal.Wass_convergence_plot() +Instead, for journals generated by MCMC, we provide way to plot the traceplot for the required parameters: + +.. code-block:: python + + journal.traceplot() + + + And certainly, a journal can easily be saved to and loaded from disk: .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py From 2e94d7bc4ad347460d3d2bb382dd72fbce3b8e2e Mon Sep 17 00:00:00 2001 From: LoryPack Date: Mon, 5 Jul 2021 12:10:33 +0200 Subject: [PATCH 09/34] Makefile and example improvements (remove prints and tmp files) --- Makefile | 4 ++++ .../gaussian_statistics_learning_DrawFromPrior_reload_NNs.py | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 74e8576..bd56734 100644 --- a/Makefile +++ b/Makefile @@ -40,6 +40,10 @@ unittest_mpi: exampletest: $(MAKEDIRS) @echo "Testing standard examples.." python3 -m unittest -v tests/test_examples.py || (echo "Error in example tests."; exit 1) + @if test -f scaler.pkl; then rm scaler.pkl; fi + @if test -f seminn_net.pth; then rm seminn_net.pth; fi + @if test -f triplet_net.pth; then rm triplet_net.pth; fi + @if test -f tmp.jnl; then rm tmp.jnl; fi exampletest_mpi: @echo "Testing MPI backend examples.." diff --git a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py index c1d4e8b..0139a7f 100644 --- a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py +++ b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py @@ -66,13 +66,13 @@ def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level= from abcpy.statistics import Identity identity = Identity() # to apply before computing the statistics - print("semiNN") + logging.info("semiNN") from abcpy.statisticslearning import SemiautomaticNN, TripletDistanceLearning semiNN = SemiautomaticNN([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations, early_stopping=True, # early stopping seed=1, n_epochs=10, scale_samples=False) - print("triplet") + logging.info("triplet") triplet = TripletDistanceLearning([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations, From 480a531c97a4f7ba9f927ff0517c821fba33cfa1 Mon Sep 17 00:00:00 2001 From: LoryPack Date: Tue, 6 Jul 2021 12:48:13 +0200 Subject: [PATCH 10/34] Fix small typo in class diagram graph --- doc/source/class-diagram.png | Bin 309094 -> 311965 bytes doc/source/class-diagram.svg | 367 +++++++++++++++++++++-------------- 2 files changed, 219 insertions(+), 148 deletions(-) diff --git a/doc/source/class-diagram.png b/doc/source/class-diagram.png index 33517d0c5d2e3c29ea91a69c129e24d9dffbcf95..66ce1f58fbfe4c38c15e2c2b4d2271a0fa413cf1 100644 GIT binary patch literal 311965 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
R#SVUzcidl#TpN$Z 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≪z3f3wxz9m-uk}G&eOlofmd}Dnk#n>X;#ky&= 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

WwxH7z`x?6#(+@ANwZq%4AWW2Td)as_f5$Hhk{ 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

@zBS8; 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

CfxY$< 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 diff --git a/doc/source/class-diagram.svg b/doc/source/class-diagram.svg index 997e28e..4b08208 100644 --- a/doc/source/class-diagram.svg +++ b/doc/source/class-diagram.svg @@ -1,23 +1,23 @@ + inkscape:export-ydpi="200" + xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" + xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" + xmlns:xlink="http://www.w3.org/1999/xlink" + xmlns="http://www.w3.org/2000/svg" + xmlns:svg="http://www.w3.org/2000/svg" + xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:cc="http://creativecommons.org/ns#" + xmlns:dc="http://purl.org/dc/elements/1.1/"> @@ -43,9 +43,9 @@ inkscape:window-height="1016" id="namedview2244" showgrid="false" - inkscape:zoom="2.114055" - inkscape:cx="224.26564" - inkscape:cy="473.59898" + inkscape:zoom="2.8284271" + inkscape:cx="413.12714" + inkscape:cy="432.57257" inkscape:window-x="0" inkscape:window-y="27" inkscape:window-maximized="1" @@ -55,7 +55,9 @@ inkscape:snap-bbox-edge-midpoints="true" inkscape:bbox-paths="true" inkscape:bbox-nodes="true" - inkscape:snap-intersection-paths="true" /> + inkscape:snap-intersection-paths="true" + inkscape:pagecheckerboard="0" + inkscape:document-units="pt" /> - - - - - - - - - - - - - - - - - - - - - - - - - + transform="translate(7.8100894e-4,43.500779)" /> - StatisticsLearning + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + StatisticsLearning + get statistics() + + + + + + From 3756d4ed6cf2a0f91fab352e0fa9528d13680d8b Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 15 Jul 2021 15:15:41 +0200 Subject: [PATCH 11/34] Add method for storing accepted simulations in Journal --- abcpy/inferences.py | 4 ++-- abcpy/output.py | 48 ++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 47 insertions(+), 5 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index e205afc..4c163d5 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -3368,7 +3368,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep 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] + accepted_y_sim = journal.get_accepted_simulations(-1) distances = journal.get_distances(-1) epsilon = journal.configuration["epsilon_arr"] @@ -3515,7 +3515,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep 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)) + journal.add_accepted_simulations(copy.deepcopy(accepted_y_sim)) names_and_parameters = self._get_names_and_parameters() journal.add_user_parameters(names_and_parameters) diff --git a/abcpy/output.py b/abcpy/output.py index 13e05b7..da28f48 100644 --- a/abcpy/output.py +++ b/abcpy/output.py @@ -39,6 +39,7 @@ def __init__(self, type): self.accepted_parameters = [] self.names_and_parameters = [] + self.accepted_simulations = [] self.weights = [] self.ESS = [] self.distances = [] @@ -114,6 +115,22 @@ def add_accepted_parameters(self, accepted_parameters): if self._type == 1: self.accepted_parameters.append(accepted_parameters) + def add_accepted_simulations(self, accepted_simulations): + """ + Saves provided accepted simulations by appending them to the journal. If type==0, old accepted simulations get + overwritten. + + Parameters + ---------- + accepted_simulations: list + """ + + if self._type == 0: + self.accepted_simulations = [accepted_simulations] + + if self._type == 1: + self.accepted_simulations.append(accepted_simulations) + def add_weights(self, weights): """ Saves provided weights by appending them to the journal. If type==0, old weights get overwritten. @@ -237,9 +254,8 @@ def get_accepted_parameters(self, iteration=None): Returns ------- - accepted_parameters: dictionary - Samples from the specified iteration (last, if not specified) returned as a disctionary with names of the - random variables + accepted_parameters: numpy.ndarray + Numpy array containing samples from the specified iteration (last, if not specified) """ if iteration is None: @@ -248,6 +264,32 @@ def get_accepted_parameters(self, iteration=None): else: return self.accepted_parameters[iteration] + def get_accepted_simulations(self, iteration=None): + """ + Returns the accepted simulations from a sampling scheme. + + For intermediate results, pass the iteration. + + simulations + ---------- + iteration: int + specify the iteration for which to return accepted simulations + + Returns + ------- + accepted_simulations: numpy.ndarray + Numpy array containing simulations corresponding to accepted samples from the specified + iteration (last, if not specified) + """ + + if iteration is None: + if len(self.accepted_simulations) == 0: + return [] + return self.accepted_simulations[-1] + + else: + return self.accepted_simulations[iteration] + def get_weights(self, iteration=None): """ Returns the weights from a sampling scheme. From c3a115eea3aaf97a1d8a0d9d547f378f8eded159 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 15 Jul 2021 15:52:11 +0200 Subject: [PATCH 12/34] Add method to store cov mats in Journal; remove outdated opt_values methods --- abcpy/inferences.py | 6 +-- abcpy/output.py | 100 ++++++++++++++++++++++++++++-------------- tests/output_tests.py | 19 -------- 3 files changed, 71 insertions(+), 54 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index 4c163d5..3a75d11 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -2131,7 +2131,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch 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] + accepted_cov_mats = journal.get_accepted_cov_mats(-1) # main ABCsubsim algorithm self.logger.info("Initialization of ABCsubsim") @@ -2230,7 +2230,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch 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) + journal.add_accepted_cov_mats(accepted_cov_mats) self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights) names_and_parameters = self._get_names_and_parameters() @@ -2255,7 +2255,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch 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) + journal.add_accepted_cov_mats(accepted_cov_mats) self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights) names_and_parameters = self._get_names_and_parameters() diff --git a/abcpy/output.py b/abcpy/output.py index da28f48..f5a818a 100644 --- a/abcpy/output.py +++ b/abcpy/output.py @@ -15,15 +15,24 @@ class Journal: Attributes ---------- - parameters : numpy.array - a nxpxt matrix - weights : numpy.array - a nxt matrix - opt_value : numpy.array - nxp matrix containing for each parameter the evaluated objective function for every time step + accepted_parameters : list + List of lists containing posterior samples + names_and_parameters : list + List of dictionaries containing posterior samples with parameter names as keys + accepted_simulations : list + List of lists containing simulations corresponding to posterior samples (this could be empty if the sampling + routine does not store those) + accepted_cov_mats : list + List of lists containing covariance matrices from accepted posterior samples (this could be empty if + the sampling routine does not store those) + weights : list + List containing posterior weights + ESS : list + List containing the Effective Sample Size (ESS) at each iteration + distances : list + List containing the ABC distance at each iteration configuration : Python dictionary dictionary containing the schemes configuration parameters - """ def __init__(self, type): @@ -40,10 +49,10 @@ def __init__(self, type): self.accepted_parameters = [] self.names_and_parameters = [] self.accepted_simulations = [] + self.accepted_cov_mats = [] self.weights = [] self.ESS = [] self.distances = [] - self.opt_values = [] self.configuration = {} if type not in [0, 1]: @@ -131,6 +140,22 @@ def add_accepted_simulations(self, accepted_simulations): if self._type == 1: self.accepted_simulations.append(accepted_simulations) + def add_accepted_cov_mats(self, accepted_cov_mats): + """ + Saves provided accepted cov_mats by appending them to the journal. If type==0, old accepted cov_mats get + overwritten. + + Parameters + ---------- + accepted_cov_mats: list + """ + + if self._type == 0: + self.accepted_cov_mats = [accepted_cov_mats] + + if self._type == 1: + self.accepted_cov_mats.append(accepted_cov_mats) + def add_weights(self, weights): """ Saves provided weights by appending them to the journal. If type==0, old weights get overwritten. @@ -163,23 +188,6 @@ def add_distances(self, distances): if self._type == 1: self.distances.append(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 - - Parameters - ---------- - opt_value: numpy.array - vector containing n evaluations of the schemes objective function - """ - - if self._type == 0: - self.opt_values = [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 @@ -254,8 +262,8 @@ def get_accepted_parameters(self, iteration=None): Returns ------- - accepted_parameters: numpy.ndarray - Numpy array containing samples from the specified iteration (last, if not specified) + accepted_parameters: list + List containing samples from the specified iteration (last, if not specified) """ if iteration is None: @@ -266,30 +274,58 @@ def get_accepted_parameters(self, iteration=None): def get_accepted_simulations(self, iteration=None): """ - Returns the accepted simulations from a sampling scheme. + Returns the accepted simulations from a sampling scheme. Notice not all sampling schemes store those in the + Journal, so this may return None. For intermediate results, pass the iteration. - simulations + Parameters ---------- iteration: int specify the iteration for which to return accepted simulations Returns ------- - accepted_simulations: numpy.ndarray - Numpy array containing simulations corresponding to accepted samples from the specified + accepted_simulations: list + List containing simulations corresponding to accepted samples from the specified iteration (last, if not specified) """ if iteration is None: if len(self.accepted_simulations) == 0: - return [] + return None return self.accepted_simulations[-1] else: return self.accepted_simulations[iteration] + def get_accepted_cov_mats(self, iteration=None): + """ + Returns the accepted cov_mats used in a sampling scheme. Notice not all sampling schemes store those in the + Journal, so this may return None. + + For intermediate results, pass the iteration. + + Parameters + ---------- + iteration: int + specify the iteration for which to return accepted cov_mats + + Returns + ------- + accepted_cov_mats: list + List containing accepted cov_mats from the specified + iteration (last, if not specified) + """ + + if iteration is None: + if len(self.accepted_cov_mats) == 0: + return None + return self.accepted_cov_mats[-1] + + else: + return self.accepted_cov_mats[iteration] + def get_weights(self, iteration=None): """ Returns the weights from a sampling scheme. diff --git a/tests/output_tests.py b/tests/output_tests.py index 7ebfd88..634f610 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -44,25 +44,6 @@ 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)) - - # test whether production mode only stores the last set of parameters - journal_prod = Journal(0) - journal_prod.add_opt_values(opt_values1) - journal_prod.add_opt_values(opt_values2) - self.assertEqual(len(journal_prod.opt_values), 1) - np.testing.assert_equal(journal_prod.opt_values[0], opt_values2) - - # test whether reconstruction mode stores all parameter sets - journal_recon = Journal(1) - journal_recon.add_opt_values(opt_values1) - journal_recon.add_opt_values(opt_values2) - self.assertEqual(len(journal_recon.opt_values), 2) - 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)) From 393428a370af7a573307a39f9092e2f28bf2ac47 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 15 Jul 2021 16:08:01 +0200 Subject: [PATCH 13/34] Some more tests --- tests/output_tests.py | 47 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/tests/output_tests.py b/tests/output_tests.py index 634f610..22cff8a 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -44,6 +44,53 @@ 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_simulations(self): + simulations1 = np.zeros((2, 4)) + simulations2 = np.ones((2, 4)) + + # test whether production mode only stores the last set of parameters + journal_prod = Journal(0) + journal_prod.add_accepted_simulations(simulations1) + journal_prod.add_accepted_simulations(simulations2) + self.assertEqual(len(journal_prod.get_accepted_simulations()), 2) + np.testing.assert_equal(journal_prod.get_accepted_simulations(), simulations2) + + # test whether reconstruction mode stores all parameter sets + journal_recon = Journal(1) + journal_recon.add_accepted_simulations(simulations1) + journal_recon.add_accepted_simulations(simulations2) + self.assertEqual(len(journal_recon.get_accepted_simulations()), 2) + np.testing.assert_equal(journal_recon.get_accepted_simulations(0), simulations1) + np.testing.assert_equal(journal_recon.get_accepted_simulations(1), simulations2) + + # test whether not storing it returns the correct value + journal_empty = Journal(0) + self.assertIsNone(journal_empty.get_accepted_simulations()) + + def test_add_cov_mats(self): + cov_mats1 = np.zeros((2, 4)) + cov_mats2 = np.ones((2, 4)) + + # test whether production mode only stores the last set of parameters + journal_prod = Journal(0) + journal_prod.add_accepted_cov_mats(cov_mats1) + journal_prod.add_accepted_cov_mats(cov_mats2) + self.assertEqual(len(journal_prod.get_accepted_cov_mats()), 2) + np.testing.assert_equal(journal_prod.get_accepted_cov_mats(), cov_mats2) + + # test whether reconstruction mode stores all parameter sets + journal_recon = Journal(1) + journal_recon.add_accepted_cov_mats(cov_mats1) + journal_recon.add_accepted_cov_mats(cov_mats2) + self.assertEqual(len(journal_recon.get_accepted_cov_mats()), 2) + np.testing.assert_equal(journal_recon.get_accepted_cov_mats(0), cov_mats1) + np.testing.assert_equal(journal_recon.get_accepted_cov_mats(1), cov_mats2) + + # test whether not storing it returns the correct value + journal_empty = Journal(0) + self.assertIsNone(journal_empty.get_accepted_cov_mats()) + + def test_load_and_save(self): params1 = np.zeros((2, 4)) weights1 = np.zeros((2, 4)) From eafbaaee195c857eba8c9403af84b7e9d52cd598 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 15 Jul 2021 16:38:42 +0200 Subject: [PATCH 14/34] Add option to not store accepted y_sim in SMCABC Journal to save memory That breaks restarting from Journal, added an error to take care of that. Also added relevant unit tests. --- abcpy/inferences.py | 31 ++++++++++++++++++++++--------- tests/inferences_tests.py | 22 ++++++++++++++++++++++ 2 files changed, 44 insertions(+), 9 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index 3a75d11..7148a86 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -2131,7 +2131,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ch 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.get_accepted_cov_mats(-1) + accepted_cov_mats = journal.get_accepted_cov_mats() # main ABCsubsim algorithm self.logger.info("Initialization of ABCsubsim") @@ -3238,8 +3238,8 @@ def __init__(self, root_models, distances, backend, kernel=None, version="DelMor self.simulation_counter = 0 def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, epsilon_final=0.1, alpha=None, - covFactor=2, resample=None, full_output=0, which_mcmc_kernel=None, r=None, journal_file=None, - path_to_save_journal=None): + covFactor=2, resample=None, full_output=0, which_mcmc_kernel=None, r=None, + store_simulations_in_journal=True, journal_file=None, path_to_save_journal=None): """Samples from the posterior distribution of the model parameter given the observed data observations. @@ -3285,6 +3285,13 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep Specifies the value of 'r' (the number of wanted hits) in the r-hits kernels. It is therefore ignored if 'which_mcmc_kernel==0'. If no value is provided, the first version of r-hit kernel uses r=3, while the second uses r=2. The default value is None. + store_simulations_in_journal : boolean, optional + Every step of the SMCABC algorithm uses the accepted simulations from previous step. Therefore, the accepted + simulations at the final step are stored in the Journal file to allow restarting the inference + correctly. If each simulation is large, however, that means that the accepted Journal will be large in + memory. If you want to *not* save the simulations in the journal, set this to False; however, you will not + be able to restart the inference from the returned Journal. The default value is True, meaning simulations + are stored in the Journal. 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. @@ -3332,6 +3339,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep accepted_weights = None accepted_cov_mats = None accepted_y_sim = None + distances = None # Define the resample parameter if resample is None: @@ -3368,7 +3376,11 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep 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.get_accepted_simulations(-1) + accepted_y_sim = journal.get_accepted_simulations() + if accepted_y_sim is None: + raise RuntimeError("You cannot restart the inference from this Journal file as you did not store " + "the simulations in it. In order to do that, the inference scheme needs to be" + "called with `store_simulations_in_journal=True`.") distances = journal.get_distances(-1) epsilon = journal.configuration["epsilon_arr"] @@ -3394,7 +3406,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep break # 0: Compute the Epsilon - if accepted_y_sim != None: + if distances is not None: self.logger.info( "Compute epsilon, might take a while; previous epsilon value: {:.4f}".format(epsilon[-1])) if self.bernton: @@ -3426,7 +3438,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep # 1: calculate weights for new parameters self.logger.info("Calculating weights") - if accepted_y_sim is not None: + if distances is not None: if self.bernton: new_weights = (current_distance_matrix < epsilon[-1]) * 1 else: @@ -3445,7 +3457,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep # 2: Resample; we resample always when using the Bernton et al. algorithm, as in that case weights # can only be proportional to 1 or 0; if we use the Del Moral version, instead, the # weights can have fractional values -> use the # resample threshold - if accepted_y_sim is not None and (self.bernton or pow(sum(pow(new_weights, 2)), -1) < resample): + if distances is not None and (self.bernton or 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) @@ -3461,7 +3473,7 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters, accepted_weights=accepted_weights) - if accepted_y_sim is not None: + if distances is not None: kernel_parameters = [] for kernel in self.kernel.kernels: kernel_parameters.append( @@ -3515,7 +3527,8 @@ def sample(self, observations, steps, n_samples=10000, n_samples_per_param=1, ep journal.add_distances(copy.deepcopy(distances)) journal.add_weights(copy.deepcopy(accepted_weights)) journal.add_ESS_estimate(accepted_weights) - journal.add_accepted_simulations(copy.deepcopy(accepted_y_sim)) + if store_simulations_in_journal: + journal.add_accepted_simulations(copy.deepcopy(accepted_y_sim)) names_and_parameters = self._get_names_and_parameters() journal.add_user_parameters(names_and_parameters) diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py index acb4d41..21fbf7c 100644 --- a/tests/inferences_tests.py +++ b/tests/inferences_tests.py @@ -892,6 +892,17 @@ def test_restart_from_journal_delmoral(self): self.assertEqual(journal_final_1.configuration["epsilon_arr"], journal_final_2.configuration["epsilon_arr"]) self.assertEqual(journal_final_1.posterior_mean()['mu'], journal_final_2.posterior_mean()['mu']) + # test now that restarting fails if I do not store simulations in the Journal at the first .sample call + sampler = SMCABC([self.model], [self.dist_calc], self.backend, seed=1) + journal_intermediate = sampler.sample([self.observation], 2, n_sample, n_simulate, + which_mcmc_kernel=which_mcmc_kernel, + store_simulations_in_journal=False) + journal_intermediate.save("tmp.jnl") + with self.assertRaises(RuntimeError): + journal_final_1 = sampler.sample([self.observation], 1, n_sample, n_simulate, + which_mcmc_kernel=which_mcmc_kernel, + journal_file="tmp.jnl") + def test_restart_from_journal_bernton(self): n_sample, n_simulate = 10, 10 # loop over standard MCMC kernel, r-hit kernel version 1 and r-hit kernel version 2 @@ -912,6 +923,17 @@ def test_restart_from_journal_bernton(self): self.assertEqual(journal_final_1.configuration["epsilon_arr"], journal_final_2.configuration["epsilon_arr"]) self.assertEqual(journal_final_1.posterior_mean()['mu'], journal_final_2.posterior_mean()['mu']) + # test now that restarting fails if I do not store simulations in the Journal at the first .sample call + sampler = SMCABC([self.model], [self.dist_calc_2], self.backend, seed=1, version="Bernton") + journal_intermediate = sampler.sample([self.observation_2], 1, n_sample, n_simulate, + which_mcmc_kernel=which_mcmc_kernel, + store_simulations_in_journal=False) + journal_intermediate.save("tmp.jnl") + with self.assertRaises(RuntimeError): + journal_final_1 = sampler.sample([self.observation_2], 1, n_sample, n_simulate, + which_mcmc_kernel=which_mcmc_kernel, + journal_file="tmp.jnl") + def test_errors(self): with self.assertRaises(RuntimeError): sampler = SMCABC([self.model], [self.dist_calc_2], self.backend, seed=1, version="DelMoral") From bf24c855e82a4234382e76810a7f27826f085867 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 15 Jul 2021 18:08:28 +0200 Subject: [PATCH 15/34] Better doc for using the Neural Network statistics learning approaches --- abcpy/NN_utilities/networks.py | 15 +++++-- abcpy/statisticslearning.py | 75 ++++++++++++++++++++++------------ doc/source/getting_started.rst | 7 ++++ 3 files changed, 66 insertions(+), 31 deletions(-) diff --git a/abcpy/NN_utilities/networks.py b/abcpy/NN_utilities/networks.py index bd411dd..556a33d 100644 --- a/abcpy/NN_utilities/networks.py +++ b/abcpy/NN_utilities/networks.py @@ -44,11 +44,18 @@ def get_embedding(self, x): 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. + given hidden layer sizes (if these are not given, they are determined from the input and output size in a heuristic + way, see below). - 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.""" + 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. + + If hidden_sizes is None, three hidden layers are used with the following sizes: + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]`` + """ class DefaultNN(nn.Module): """Neural network class with sizes determined by the upper level variables.""" diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index 32a7695..ed567f6 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -228,7 +228,7 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe model: abcpy.models.Model Model object that conforms to the Model class. statistics_cal: abcpy.statistics.Statistics - Statistics object that conforms to the Statistics class. + Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. n_samples: int, optional @@ -293,7 +293,7 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l model: abcpy.models.Model Model object that conforms to the Model class. statistics_cal: abcpy.statistics.Statistics - Statistics object that conforms to the Statistics class. + Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. training_routine: function @@ -304,11 +304,17 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l this has to be True if the statistics learning technique is based on distance learning, in which case the __init__ computes the similarity matrix. embedding_net: torch.nn object or list - it can be a torch.nn object with input size corresponding to size of model output, alternatively, a list + it can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`), alternatively, a list with integer numbers denoting the width of the hidden layers, from which a fully connected network with - that structure is created, having the input and output size corresponding to size of model output and - number of parameters. In case this is None, the depth of the network and the width of the hidden layers is - determined from the input and output size as specified in abcpy.NN_utilities.networks.DefaultNN. + that structure is created, having the input and output size corresponding to size of model output + (after being transformed by `statistics_calc`) and + number of parameters. In case this is None, a fully connected neural network with three hidden layers is + used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` + is the number of parameters in the model. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN` n_samples: int, optional The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot step. The default value is 1000. @@ -533,16 +539,21 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample model: abcpy.models.Model Model object that conforms to the Model class. statistics_cal: abcpy.statistics.Statistics - Statistics object that conforms to the Statistics class. + Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. embedding_net: torch.nn object or list - it can be a torch.nn object with input size corresponding to size of model output and output size - corresponding to the number of parameters or, alternatively, a list with integer numbers denoting the width - of the hidden layers, from which a fully connected network with that structure is created, having the input - and output size corresponding to size of model output and number of parameters. In case this is None, the - depth of the network and the width of the hidden layers is determined from the input and output size as - specified in abcpy.NN_utilities.networks.DefaultNN. + it can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`), alternatively, a list + with integer numbers denoting the width of the hidden layers, from which a fully connected network with + that structure is created, having the input and output size corresponding to size of model output + (after being transformed by `statistics_calc`) and + number of parameters. In case this is None, a fully connected neural network with three hidden layers is + used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` + is the number of parameters in the model. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN` n_samples: int, optional The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot step. The default value is 1000. @@ -674,16 +685,21 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample model: abcpy.models.Model Model object that conforms to the Model class. statistics_cal: abcpy.statistics.Statistics - Statistics object that conforms to the Statistics class. + Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. embedding_net: torch.nn object or list - it can be a torch.nn object with input size corresponding to size of model output (output size can be any); - alternatively, a list with integer numbers denoting the width of the hidden layers, from which a fully - connected network with that structure is created, having the input and output size corresponding to size of - model output and number of parameters. In case this is None, the depth of the network and the width of the - hidden layers is determined from the input and output size as specified in - abcpy.NN_utilities.networks.DefaultNN. + it can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`), alternatively, a list + with integer numbers denoting the width of the hidden layers, from which a fully connected network with + that structure is created, having the input and output size corresponding to size of model output + (after being transformed by `statistics_calc`) and + number of parameters. In case this is None, a fully connected neural network with three hidden layers is + used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` + is the number of parameters in the model. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN` n_samples: int, optional The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot step. The default value is 1000. @@ -824,16 +840,21 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample model: abcpy.models.Model Model object that conforms to the Model class. statistics_cal: abcpy.statistics.Statistics - Statistics object that conforms to the Statistics class. + Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. embedding_net: torch.nn object or list - it can be a torch.nn object with input size corresponding to size of model output (output size can be any); - alternatively, a list with integer numbers denoting the width of the hidden layers, from which a fully - connected network with that structure is created, having the input and output size corresponding to size of - model output and number of parameters. In case this is None, the depth of the network and the width of the - hidden layers is determined from the input and output size as specified in - abcpy.NN_utilities.networks.DefaultNN. + it can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`), alternatively, a list + with integer numbers denoting the width of the hidden layers, from which a fully connected network with + that structure is created, having the input and output size corresponding to size of model output + (after being transformed by `statistics_calc`) and + number of parameters. In case this is None, a fully connected neural network with three hidden layers is + used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` + is the number of parameters in the model. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN` n_samples: int, optional The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot step. The default value is 1000. diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst index c317180..1edb5b9 100644 --- a/doc/source/getting_started.rst +++ b/doc/source/getting_started.rst @@ -407,6 +407,13 @@ We remark that the minimal amount of coding needed for using the neural network And similarly for the other two approaches. +We remark how :py:class:`abcpy.statisticslearning.SemiautomaticNN` (as well as the other NN-based statistics learning approaches) allow to specify a neural network through the optional `embedding_net` parameter. According to the value given to it, different NNs are used: + +* a torch.nn object can be passed to `embedding_net` to be used as the NN to learn summary statistics. +* Alternatively, a list with some integer numbers denoting the width of the hidden layers of a fully connected NN can be specified (with the length of the list corresponding to the number of hidden layers). In this case, the input and output sizes are determined so that things work correctly: input size correspond to the data size after the provided `statistics_calculator` has been applied, while output size corresponds to the number of parameters in the model. The function taking care of instantiating the NN is :py:func:`abcpy.NN_utilities.networks.createDefaultNN`. +* If `embedding_net` is not specified, the behavior is similar to the latter bullet point, but with the number of hidden sizes fixed to 3 and their width determined as: ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``. + + We can then perform the inference as before, but the distances will be computed on the newly learned summary statistics. The above summary statistics learning routines can also be initialized with previously generated parameter-observation pairs (this can be useful for instance when different statistics learning techniques need to be tested with the same training dataset). The :py:class:`abcpy.inferences.DrawFromPrior` class can be used to generate such training data. We provide an example showcasing this in `examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py `_. From 5ddeb3cba79244fc6e6f90a3c2add90eb80fcb81 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Fri, 16 Jul 2021 15:43:31 +0200 Subject: [PATCH 16/34] Refactor code for DrawFromPrior and better use of chunks --- abcpy/inferences.py | 89 ++++++++++++++++++++------------------- tests/inferences_tests.py | 50 ++++++++++++++++------ 2 files changed, 84 insertions(+), 55 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index e205afc..edfb76f 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -158,6 +158,9 @@ class DrawFromPrior(InferenceMethod): `sample_par_sim_pairs` method generates (parameter, simulation) pairs, which can be used for instance as a training dataset for the automatic learning of summary statistics with the StatisticsLearning classes. + When generating large datasets with MPI backend, pickling may give overflow error; for this reason, the methods + split the generation in "chunks" of the specified size on which the parallelization is used. + Parameters ---------- root_models: list @@ -166,6 +169,8 @@ class DrawFromPrior(InferenceMethod): Backend object defining the backend to be used. seed: integer, optional Optional initial seed for the random number generator. The default value is generated randomly. + max_chunk_size: integer, optional + Maximum size of chunks in which to split the data generation. Defaults to 10**4 discard_too_large_values: boolean If set to True, the simulation is discarded (and repeated) if at least one element of it is too large to fit in float32, which therefore may be converted to infinite value in numpy. Defaults to False. @@ -178,10 +183,11 @@ class DrawFromPrior(InferenceMethod): n_samples_per_param = None # this needs to be there otherwise it does not instantiate correctly - def __init__(self, root_models, backend, seed=None, discard_too_large_values=False): + def __init__(self, root_models, backend, seed=None, max_chunk_size=10 ** 4, discard_too_large_values=False): self.model = root_models self.backend = backend self.rng = np.random.RandomState(seed) + self.max_chunk_size = max_chunk_size self.discard_too_large_values = discard_too_large_values # An object managing the bds objects self.accepted_parameters_manager = AcceptedParametersManager(self.model) @@ -206,30 +212,16 @@ def sample(self, n_samples, path_to_save_journal=None): journal = Journal(1) journal.configuration["type_model"] = [type(model).__name__ for model in self.model] - journal.configuration["n_samples"] = self.n_samples - - # the following lines are similar to the RejectionABC code but only sample from the prior. - # now generate an array of seeds that need to be different one from the other. One way to do it is the - # following. - # Moreover, you cannot use int64 as seeds need to be < 2**32 - 1. How to fix this? - # Note that this is not perfect; you still have small possibility of having some seeds that are equal. Is there - # a better way? This would likely not change much the performance - # An idea would be to use rng.choice but that is too expensive - seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32) - # check how many equal seeds there are and remove them: - sorted_seed_arr = np.sort(seed_arr) - indices = sorted_seed_arr[:-1] == sorted_seed_arr[1:] - if np.sum(indices) > 0: - # the following removes the equal seeds in case there are some - sorted_seed_arr[:-1][indices] = sorted_seed_arr[:-1][indices] + 1 - rng_arr = np.array([np.random.RandomState(seed) for seed in sorted_seed_arr]) - rng_pds = self.backend.parallelize(rng_arr) + journal.configuration["n_samples"] = n_samples - parameters_pds = self.backend.map(self._sample_parameter_only, rng_pds) - parameters = self.backend.collect(parameters_pds) - # accepted_parameters, distances, counter = [list(t) for t in zip(*accepted_parameters_distances_counter)] + # we split sampling in chunks to avoid error in case MPI is used + parameters = [] + samples_to_sample = n_samples + while samples_to_sample > 0: + parameters_part = self._sample(min(samples_to_sample, self.max_chunk_size)) + samples_to_sample -= self.max_chunk_size + parameters += parameters_part - self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=parameters) journal.add_accepted_parameters(copy.deepcopy(parameters)) journal.add_weights(np.ones((n_samples, 1))) journal.add_ESS_estimate(np.ones((n_samples, 1))) @@ -243,23 +235,18 @@ def sample(self, n_samples, path_to_save_journal=None): return journal - def sample_par_sim_pairs(self, n_samples, n_samples_per_param, max_chunk_size=10 ** 4): + def sample_par_sim_pairs(self, n_samples, n_samples_per_param): """ Samples (parameter, simulation) pairs from the prior distribution from the model distribution. Specifically, parameter values are sampled from the prior and used to generate the specified number of simulations per parameter value. This returns arrays. - When generating large datasets with MPI backend, pickling may give overflow error; for this reason, the function - splits the generation in "chunks" of the specified size on which the parallelization is used. - Parameters ---------- n_samples: integer Number of samples to generate n_samples_per_param: integer Number of data points in each simulated data set. - max_chunk_size: integer, optional - Maximum size of chunks in which to split the data generation. Defaults to 10**4 Returns ------- @@ -274,15 +261,26 @@ def sample_par_sim_pairs(self, n_samples, n_samples_per_param, max_chunk_size=10 simulations_list = [] samples_to_sample = n_samples while samples_to_sample > 0: - parameters_part, simulations_part = self._sample_par_sim_pairs(min(samples_to_sample, max_chunk_size), + parameters_part, simulations_part = self._sample_par_sim_pairs(min(samples_to_sample, self.max_chunk_size), n_samples_per_param) - samples_to_sample -= max_chunk_size + samples_to_sample -= self.max_chunk_size parameters_list.append(parameters_part) simulations_list.append(simulations_part) parameters = np.concatenate(parameters_list) simulations = np.concatenate(simulations_list) return parameters, simulations + def _sample(self, n_samples): + + # the following lines are similar to the RejectionABC code but only sample from the prior. + + # generate the rng_pds + rng_pds = self._generate_rng_pds(n_samples) + + parameters_pds = self.backend.map(self._sample_parameter_only, rng_pds) + parameters = self.backend.collect(parameters_pds) + return parameters + def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): """ Not for end use; please use `sample_par_sim_pairs`. @@ -312,6 +310,22 @@ def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): self.n_samples_per_param = n_samples_per_param self.accepted_parameters_manager.broadcast(self.backend, 1) + # generate the rng_pds + rng_pds = self._generate_rng_pds(n_samples) + + parameters_simulations_pds = self.backend.map(self._sample_parameter_simulation, rng_pds) + parameters_simulations = self.backend.collect(parameters_simulations_pds) + parameters, simulations = [list(t) for t in zip(*parameters_simulations)] + + parameters = np.array(parameters) + simulations = np.array(simulations) + + parameters = parameters.reshape((parameters.shape[0], parameters.shape[1])) + simulations = simulations.reshape((simulations.shape[0], simulations.shape[2], simulations.shape[3],)) + + return parameters, simulations + + def _generate_rng_pds(self, n_samples): # now generate an array of seeds that need to be different one from the other. One way to do it is the # following. # Moreover, you cannot use int64 as seeds need to be < 2**32 - 1. How to fix this? @@ -327,18 +341,7 @@ def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): sorted_seed_arr[:-1][indices] = sorted_seed_arr[:-1][indices] + 1 rng_arr = np.array([np.random.RandomState(seed) for seed in sorted_seed_arr]) rng_pds = self.backend.parallelize(rng_arr) - - parameters_simulations_pds = self.backend.map(self._sample_parameter_simulation, rng_pds) - parameters_simulations = self.backend.collect(parameters_simulations_pds) - parameters, simulations = [list(t) for t in zip(*parameters_simulations)] - - parameters = np.array(parameters) - simulations = np.array(simulations) - - parameters = parameters.reshape((parameters.shape[0], parameters.shape[1])) - simulations = simulations.reshape((simulations.shape[0], simulations.shape[2], simulations.shape[3],)) - - return parameters, simulations + return rng_pds def _sample_parameter_simulation(self, rng, npc=None): """ diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py index acb4d41..8b2af92 100644 --- a/tests/inferences_tests.py +++ b/tests/inferences_tests.py @@ -23,18 +23,17 @@ def setUp(self): # define a Gaussian model self.model = Normal([mu, sigma]) - # create fake observed data - self.y_obs = [np.array(9.8)] - - # for correct seeding define 2 samplers (and discard large values in the second to test if that works) + # for correct seeding define 4 samplers (and discard large values in 3nd and 4rd to test if that works) self.sampler = DrawFromPrior([self.model], dummy, seed=1) - self.sampler2 = DrawFromPrior([self.model], dummy, seed=1, discard_too_large_values=True) + self.sampler2 = DrawFromPrior([self.model], dummy, seed=1, max_chunk_size=2) + self.sampler3 = DrawFromPrior([self.model], dummy, seed=1, discard_too_large_values=True) + self.sampler4 = DrawFromPrior([self.model], dummy, seed=1, discard_too_large_values=True, max_chunk_size=2 ) # expected mean values from 100 prior samples: self.mu_mean = -0.24621316447913139 self.sigma_mean = 5.182264389159227 - def test_sample_n_samples(self): + def test_sample(self): # test drawing parameter values from the prior in a similar fashion to the other InferenceMethdod's journal = self.sampler.sample(100, path_to_save_journal="tmp.jnl") mu_sample = np.array(journal.get_parameters()['mu']) @@ -56,6 +55,27 @@ def test_sample_n_samples(self): self.assertTrue(journal.number_of_simulations[0] == 0) + # test now it gives same results with max_chunk_size=2 + journal2 = self.sampler2.sample(100) + mu_sample = np.array(journal2.get_parameters()['mu']) + sigma_sample = np.array(journal2.get_parameters()['sigma']) + + accepted_parameters = journal2.get_accepted_parameters() + self.assertEqual(len(accepted_parameters), 100) + self.assertEqual(len(accepted_parameters[0]), 2) + + # 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, (100, 1)) + self.assertEqual(sigma_shape, (100, 1)) + + # Compute posterior mean + self.assertAlmostEqual(np.average(mu_sample), self.mu_mean) + self.assertAlmostEqual(np.average(sigma_sample), self.sigma_mean) + + self.assertTrue(journal2.number_of_simulations[0] == 0) + def test_param_simulation_pairs(self): # sample single simulation for each par value parameters, simulations = self.sampler.sample_par_sim_pairs(10, 1) @@ -67,17 +87,23 @@ def test_param_simulation_pairs(self): self.assertEqual(parameters.shape, (10, 2)) self.assertEqual(simulations.shape, (10, 3, 1)) - # try with smaller max_chunk_size - parameters, simulations = self.sampler.sample_par_sim_pairs(10, 3, max_chunk_size=2) - self.assertEqual(parameters.shape, (10, 2)) - self.assertEqual(simulations.shape, (10, 3, 1)) - # now run with the new sampler to check if the means are the same as with `.sample` method: - parameters, simulations = self.sampler2.sample_par_sim_pairs(100, 1) + parameters, simulations = self.sampler3.sample_par_sim_pairs(100, 1) means = np.mean(parameters, axis=0) self.assertAlmostEqual(means[0], self.mu_mean) self.assertAlmostEqual(means[1], self.sigma_mean) + # check also if that gives same results by splitting in chunks: + parameters, simulations = self.sampler4.sample_par_sim_pairs(100, 1) + means = np.mean(parameters, axis=0) + self.assertAlmostEqual(means[0], self.mu_mean) + self.assertAlmostEqual(means[1], self.sigma_mean) + + # check sizes with smaller max_chunk_size + parameters, simulations = self.sampler4.sample_par_sim_pairs(10, 3) + self.assertEqual(parameters.shape, (10, 2)) + self.assertEqual(simulations.shape, (10, 3, 1)) + class RejectionABCTest(unittest.TestCase): def setUp(self): From 1ceddc7ff881272277cb1d2d7b57f66d169c8ba7 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Tue, 20 Jul 2021 15:22:03 +0200 Subject: [PATCH 17/34] Minor improvements in DrawFromPrior --- abcpy/inferences.py | 36 +++++++++++++++++++++++++++++++++--- tests/inferences_tests.py | 4 ++-- 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/abcpy/inferences.py b/abcpy/inferences.py index edfb76f..7aa0c01 100644 --- a/abcpy/inferences.py +++ b/abcpy/inferences.py @@ -257,6 +257,7 @@ def sample_par_sim_pairs(self, n_samples, n_samples_per_param): each simulation. """ + # we split sampling in chunks to avoid error in case MPI is used parameters_list = [] simulations_list = [] samples_to_sample = n_samples @@ -271,7 +272,22 @@ def sample_par_sim_pairs(self, n_samples, n_samples_per_param): return parameters, simulations def _sample(self, n_samples): + """ + Not for end use; please use `sample`. + + Samples model parameters from the prior distribution. This is an helper function called by the main `sample` one + in order to split drawing from the prior in chunks to avoid parallelization issues with MPI. + + Parameters + ---------- + n_samples: integer + Number of samples to generate + Returns + ------- + list + List containing sampled parameter values. + """ # the following lines are similar to the RejectionABC code but only sample from the prior. # generate the rng_pds @@ -289,14 +305,15 @@ def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): parameter values are sampled from the prior and used to generate the specified number of simulations per parameter value. This returns arrays. + This is an helper function called by the main `sample_par_sim_pair` one + in order to split drawing from the prior in chunks to avoid parallelization issues with MPI. + Parameters ---------- n_samples: integer Number of samples to generate n_samples_per_param: integer Number of data points in each simulated data set. - max_chunk_size: integer, optional - Maximum size of chunks in which to split the data generation. Defaults to 10**4 Returns ------- @@ -306,7 +323,6 @@ def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): of the tuple is an array with shape (n_samples, n_samples_per_param, d_x), where d_x is the dimension of each simulation. """ - self.n_samples = n_samples self.n_samples_per_param = n_samples_per_param self.accepted_parameters_manager.broadcast(self.backend, 1) @@ -326,6 +342,20 @@ def _sample_par_sim_pairs(self, n_samples, n_samples_per_param): return parameters, simulations def _generate_rng_pds(self, n_samples): + """Helper function to generate the random seeds which are used in sampling from prior and simulating from the + model in the parallel setup. + + Parameters + ---------- + n_samples: integer + Number of random seeds (corresponing to number of prior samples) to generate + + Returns + ------- + list + A (possibly distributed according to the used backend) list containing the random seeds to be assigned to + each worker. + """ # now generate an array of seeds that need to be different one from the other. One way to do it is the # following. # Moreover, you cannot use int64 as seeds need to be < 2**32 - 1. How to fix this? diff --git a/tests/inferences_tests.py b/tests/inferences_tests.py index 8b2af92..ea6a9db 100644 --- a/tests/inferences_tests.py +++ b/tests/inferences_tests.py @@ -12,7 +12,7 @@ from abcpy.statistics import Identity -class DrawFromPriorTest(unittest.TestCase): +class DrawFromPriorTests(unittest.TestCase): def setUp(self): # setup backend dummy = BackendDummy() @@ -105,7 +105,7 @@ def test_param_simulation_pairs(self): self.assertEqual(simulations.shape, (10, 3, 1)) -class RejectionABCTest(unittest.TestCase): +class RejectionABCTests(unittest.TestCase): def setUp(self): # setup backend dummy = BackendDummy() From 6647f65fa8c53418d5439580c3912b122753d331 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Tue, 20 Jul 2021 16:23:16 +0200 Subject: [PATCH 18/34] Add new method to Journal to perform posterior resampling. --- abcpy/output.py | 106 ++++++++++++++++++++++++++++++++++++++++++ tests/output_tests.py | 98 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 204 insertions(+) diff --git a/abcpy/output.py b/abcpy/output.py index 13e05b7..e1a92f8 100644 --- a/abcpy/output.py +++ b/abcpy/output.py @@ -1,3 +1,4 @@ +import copy import pickle import warnings @@ -928,3 +929,108 @@ def traceplot(self, parameters_to_show=None, iteration=None, **kwargs): ax[i].set_xlabel("MCMC step") return fig, ax + + def resample(self, n_samples=None, replace=True, path_to_save_journal=None, seed=None): + """ + Helper method to resample (by bootstrapping or subsampling) the posterior samples stored in the Journal. + This can be used for instance to obtain an unweighted set of + posterior samples from a weighted one (via bootstrapping) or + to subsample a given number of posterior samples from a larger set. The new set of (unweighted) + samples are stored in a new journal which is returned by the method. + + In order to bootstrap/subsample, the ``np.random.choice`` method is used, with the posterior sample + weights used as + probabilities (p) for resampling each sample. ``np.random.choice`` performs resampling with or without + replacement according to whether ``replace=True`` or ``replace=False``. Moreover, the parameter + ``n_samples`` specifies the number of resampled samples + (and is set by default to the number of samples in the journal). Therefore, different combinations of these + two parameters can be used to bootstrap or to subsample a set of posterior samples (see the examples below); + the default parameter values perform bootstrap. + + Parameters + ---------- + n_samples: integer, optional + The number of posterior samples which you want to resample. Defaults to the number of posterior samples + currently stored in the Journal. + replace: boolean, optional + If True, sampling with replacement is performed; if False, sampling without replacement. Defaults to False. + path_to_save_journal: str, optional + If provided, save the journal with the resampled posterior samples at the provided path. + seed: integer, optional + Optional initial seed for the random number generator. The default value is generated randomly. + + Returns + ------- + abcpy.output.Journal + a journal containing the resampled posterior samples + + Examples + -------- + If ``journal`` contains a weighted set of posterior samples, the following returns an unweighted bootstrapped + set of posterior samples, stored in ``new_journal``: + + >>> new_journal = journal.resample() + + The above of course also works when the original posterior samples are unweighted. + + If ``journal`` contains a here a large number of posterior sampling, you can subsample (without replacement) + a smaller number of them (say 100) with the following line (and store them in ``new_journal``): + + >>> new_journal = journal.resample(n_samples=100, replace=False) + + Notice that the above takes into account the weights in the original ``journal``. + + """ + + # instantiate the random number generator + rng = np.random.RandomState(seed) + + # this extracts the parameters from the journal + accepted_parameters = self.get_accepted_parameters(-1) + accepted_weights = self.get_weights(-1) + n_samples_old = self.configuration["n_samples"] + normalized_weights = accepted_weights.reshape(-1) / np.sum(accepted_weights) + + n_samples = n_samples_old if n_samples is None else n_samples + + if n_samples > n_samples_old and not replace: + raise RuntimeError("You cannot draw without replacement a larger number of samples than the posterior " + "samples currently stored in the journal.") + + # here you just need to bootstrap (or subsample): + bootstrapped_parameter_indices = rng.choice(np.arange(n_samples_old), size=n_samples, replace=replace, + p=normalized_weights) + bootstrapped_parameters = [accepted_parameters[index] for index in bootstrapped_parameter_indices] + + # define new journal + journal_new = Journal(0) + journal_new.configuration["type_model"] = self.configuration["type_model"] + journal_new.configuration["n_samples"] = n_samples + + # store bootstrapped parameters in new journal + journal_new.add_accepted_parameters(copy.deepcopy(bootstrapped_parameters)) + journal_new.add_weights(np.ones((n_samples, 1))) + journal_new.add_ESS_estimate(np.ones((n_samples, 1))) + + # the next piece of code build the list to be passed to add_user_parameter in order to build the dictionary; + # this mimics the behavior of what is done in the InferenceMethod's using the lines: + # `self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters)` + # `names_and_parameters = self._get_names_and_parameters()` + + names_par_dicts = self.get_parameters() + par_names = list(names_par_dicts.keys()) + new_names_par_list = [] + start_index = 0 + for name in par_names: + parameter_size = len(names_par_dicts[name][0]) # the size of that parameter + name_par_tuple = ( + name, [bootstrapped_parameters[i][start_index:start_index + parameter_size] for i in range(n_samples)]) + new_names_par_list.append(name_par_tuple) + start_index += parameter_size + journal_new.add_user_parameters(new_names_par_list) + journal_new.number_of_simulations.append(0) + + if path_to_save_journal is not None: # save journal + journal_new.save(path_to_save_journal) + + return journal_new diff --git a/tests/output_tests.py b/tests/output_tests.py index 7ebfd88..4771a20 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -2,6 +2,10 @@ import numpy as np +from abcpy.backends import BackendDummy +from abcpy.continuousmodels import Normal +from abcpy.continuousmodels import Uniform +from abcpy.inferences import DrawFromPrior from abcpy.output import Journal @@ -184,6 +188,100 @@ def test_traceplot(self): # now try correctly: fig, ax = journal.traceplot() + def test_resample(self): + # -- setup -- + # setup backend + dummy = 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 + model = Normal([mu, sigma]) + + sampler = DrawFromPrior([model], dummy, seed=1) + original_journal = sampler.sample(100) + + # expected mean values from bootstrapped samples: + mu_mean = -0.5631214403709973 + sigma_mean = 5.2341427118053705 + # expected mean values from subsampled samples: + mu_mean_2 = -0.6414897172489 + sigma_mean_2 = 6.217381777130734 + + # -- bootstrap -- + new_j = original_journal.resample(path_to_save_journal="tmp.jnl", seed=42) + mu_sample = np.array(new_j.get_parameters()['mu']) + sigma_sample = np.array(new_j.get_parameters()['sigma']) + + accepted_parameters = new_j.get_accepted_parameters() + self.assertEqual(len(accepted_parameters), 100) + self.assertEqual(len(accepted_parameters[0]), 2) + + # 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, (100, 1)) + self.assertEqual(sigma_shape, (100, 1)) + + # Compute posterior mean + self.assertAlmostEqual(np.average(mu_sample), mu_mean) + self.assertAlmostEqual(np.average(sigma_sample), sigma_mean) + + self.assertTrue(new_j.number_of_simulations[0] == 0) + + # check whether the dictionary or parameter list contain same data: + self.assertEqual(new_j.get_parameters()["mu"][9], new_j.get_accepted_parameters()[9][0]) + self.assertEqual(new_j.get_parameters()["sigma"][7], new_j.get_accepted_parameters()[7][1]) + + # -- subsample (replace=False, smaller number than the full sample) -- + new_j_2 = original_journal.resample(replace=False, n_samples=10, seed=42) + mu_sample = np.array(new_j_2.get_parameters()['mu']) + sigma_sample = np.array(new_j_2.get_parameters()['sigma']) + + accepted_parameters = new_j_2.get_accepted_parameters() + self.assertEqual(len(accepted_parameters), 10) + self.assertEqual(len(accepted_parameters[0]), 2) + + # 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)) + + # Compute posterior mean + self.assertAlmostEqual(np.average(mu_sample), mu_mean_2) + self.assertAlmostEqual(np.average(sigma_sample), sigma_mean_2) + + self.assertTrue(new_j_2.number_of_simulations[0] == 0) + + # check whether the dictionary or parameter list contain same data: + self.assertEqual(new_j_2.get_parameters()["mu"][9], new_j_2.get_accepted_parameters()[9][0]) + self.assertEqual(new_j_2.get_parameters()["sigma"][7], new_j_2.get_accepted_parameters()[7][1]) + + # -- check that resampling the full samples with replace=False gives the exact same posterior mean and std -- + new_j_3 = original_journal.resample(replace=False, n_samples=100) + mu_sample = np.array(new_j_3.get_parameters()['mu']) + sigma_sample = np.array(new_j_3.get_parameters()['sigma']) + + # original journal + mu_sample_original = np.array(original_journal.get_parameters()['mu']) + sigma_sample_original = np.array(original_journal.get_parameters()['sigma']) + + # Compute posterior mean and std + self.assertAlmostEqual(np.average(mu_sample), np.average(mu_sample_original)) + self.assertAlmostEqual(np.average(sigma_sample), np.average(sigma_sample_original)) + self.assertAlmostEqual(np.std(mu_sample), np.std(mu_sample_original)) + self.assertAlmostEqual(np.std(sigma_sample), np.std(sigma_sample_original)) + + # check whether the dictionary or parameter list contain same data: + self.assertEqual(new_j_3.get_parameters()["mu"][9], new_j_3.get_accepted_parameters()[9][0]) + self.assertEqual(new_j_3.get_parameters()["sigma"][7], new_j_3.get_accepted_parameters()[7][1]) + + # -- test the error -- + with self.assertRaises(RuntimeError): + original_journal.resample(replace=False, n_samples=200) + if __name__ == '__main__': unittest.main() From bc388300c1f29c28ecafe47b23730bf003f98bbc Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Tue, 20 Jul 2021 17:18:26 +0200 Subject: [PATCH 19/34] Add code to generate simulations starting from a journal --- abcpy/output.py | 147 +++++++++++++++++++++++++++++++++++- doc/source/postanalysis.rst | 67 +++++++++++++--- tests/output_tests.py | 49 +++++++++++- 3 files changed, 249 insertions(+), 14 deletions(-) diff --git a/abcpy/output.py b/abcpy/output.py index e1a92f8..58d5000 100644 --- a/abcpy/output.py +++ b/abcpy/output.py @@ -6,6 +6,8 @@ import numpy as np from scipy.stats import gaussian_kde +from abcpy.acceptedparametersmanager import AcceptedParametersManager +from abcpy.graphtools import GraphTools from abcpy.utils import wass_dist @@ -943,7 +945,8 @@ def resample(self, n_samples=None, replace=True, path_to_save_journal=None, seed probabilities (p) for resampling each sample. ``np.random.choice`` performs resampling with or without replacement according to whether ``replace=True`` or ``replace=False``. Moreover, the parameter ``n_samples`` specifies the number of resampled samples - (and is set by default to the number of samples in the journal). Therefore, different combinations of these + (the ``size`` argument of ``np.ranodom.choice``) and is set by + default to the number of samples in the journal). Therefore, different combinations of these two parameters can be used to bootstrap or to subsample a set of posterior samples (see the examples below); the default parameter values perform bootstrap. @@ -1034,3 +1037,145 @@ def resample(self, n_samples=None, replace=True, path_to_save_journal=None, seed journal_new.save(path_to_save_journal) return journal_new + + +class GenerateFromJournal(GraphTools): + """Helper class to generate simulations from a model starting from the parameter values stored in a Journal file. + + Parameters + ---------- + root_models: list + A list of the Probabilistic models corresponding to the observed datasets + backend: abcpy.backends.Backend + Backend object defining the backend to be used. + seed: integer, optional + Optional initial seed for the random number generator. The default value is generated randomly. + discard_too_large_values: boolean + If set to True, the simulation is discarded (and repeated) if at least one element of it is too large + to fit in float32, which therefore may be converted to infinite value in numpy. Defaults to False. + + Examples + -------- + Simplest possible usage is: + + >>> generate_from_journal = GenerateFromJournal([model], backend=backend) + >>> parameters, simulations, normalized_weights = generate_from_journal.generate(journal) + + which takes the parameter values stored in journal and generated simulations from them. Notice how the method + returns (in this order) the parameter values used for the simulations, the simulations themselves and the + posterior weights associated to the parameters. All of these three objects are numpy arrays. + + """ + + def __init__(self, root_models, backend, seed=None, discard_too_large_values=False): + self.model = root_models + self.backend = backend + self.rng = np.random.RandomState(seed) + self.discard_too_large_values = discard_too_large_values + # An object managing the bds objects + self.accepted_parameters_manager = AcceptedParametersManager(self.model) + + def generate(self, journal, n_samples_per_param=1, iteration=None): + """ + Method to generate simulations using parameter values stored in the provided Journal. + + Parameters + ---------- + journal: abcpy.output.Journal + the Journal containing the parameter values from which to generate simulations from the model. + n_samples_per_param: integer, optional + Number of simulations for each parameter value. Defaults to 1. + iteration: integer, optional + specifies the iteration from which the parameter samples in the Journal are taken to generate simulations. + If None (default), it uses the last iteration. + + Returns + ------- + tuple + A tuple of numpy ndarray's containing the parameter values (first element, with shape n_samples x d_theta), + the generated + simulations (second element, with shape n_samples x n_samples_per_param x d_x, where d_x is the dimension of + each simulation) and the normalized weights attributed to each parameter value + (third element, with shape n_samples). + + Examples + -------- + Simplest possible usage is: + + >>> generate_from_journal = GenerateFromJournal([model], backend=backend) + >>> parameters, simulations, normalized_weights = generate_from_journal.generate(journal) + + which takes the parameter values stored in journal and generated simulations from them. Notice how the method + returns (in this order) the parameter values used for the simulations, the simulations themselves and the + posterior weights associated to the parameters. All of these three objects are numpy arrays. + + """ + # check whether the model corresponds to the one for which the journal was generated + if journal.configuration["type_model"] != [type(model).__name__ for model in self.model]: + raise RuntimeError("You are not using the same model as the one with which the journal was generated.") + + self.n_samples_per_param = n_samples_per_param + + accepted_parameters = journal.get_accepted_parameters(iteration) + accepted_weights = journal.get_weights(iteration) + normalized_weights = accepted_weights.reshape(-1) / np.sum(accepted_weights) + n_samples = len(normalized_weights) + + self.accepted_parameters_manager.broadcast(self.backend, [None]) + # Broadcast Accepted parameters + self.accepted_parameters_manager.update_broadcast(self.backend, accepted_parameters=accepted_parameters) + + seed_arr = self.rng.randint(0, np.iinfo(np.uint32).max, size=n_samples, dtype=np.uint32) + # no need to check if the seeds are the same here as they are assigned to different parameter values + rng_arr = np.array([np.random.RandomState(seed) for seed in seed_arr]) + index_arr = np.arange(0, n_samples, 1) + data_arr = [] + for i in range(len(rng_arr)): + data_arr.append([rng_arr[i], index_arr[i]]) + data_pds = self.backend.parallelize(data_arr) + + simulations_pds = self.backend.map(self._sample_parameter, data_pds) + simulations = self.backend.collect(simulations_pds) + + parameters = np.array(accepted_parameters) + simulations = np.array(simulations) + + parameters = parameters.reshape((parameters.shape[0], parameters.shape[1])) + simulations = simulations.reshape((simulations.shape[0], simulations.shape[2], simulations.shape[3],)) + + return parameters, simulations, normalized_weights + + def _sample_parameter(self, data, npc=None): + """ + Simulates from a single model parameter. + + Parameters + ---------- + data: list + A list containing a random numpy state and a parameter index, e.g. [rng, index] + + Returns + ------- + numpy.ndarray + The simulated dataset. + """ + + if isinstance(data, np.ndarray): + data = data.tolist() + rng = data[0] + index = data[1] + + parameter = self.accepted_parameters_manager.accepted_parameters_bds.value()[index] + ok_flag = False + + while not ok_flag: + self.set_parameters(parameter) + y_sim = self.simulate(n_samples_per_param=self.n_samples_per_param, rng=rng, npc=npc) + # if there are no potential infinities there (or if we do not check for those). + # For instance, Lorenz model may give too large values sometimes (quite rarely). + if self.discard_too_large_values and np.sum(np.isinf(np.array(y_sim).astype("float32"))) > 0: + self.logger.warning("y_sim contained too large values for float32; simulating again.") + else: + ok_flag = True + + return y_sim diff --git a/doc/source/postanalysis.rst b/doc/source/postanalysis.rst index 001142d..3f6dcd5 100644 --- a/doc/source/postanalysis.rst +++ b/doc/source/postanalysis.rst @@ -4,31 +4,33 @@ ================ 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 -weights using: +Basis Analysis +~~~~~~~~~~~~~~ + +One can easily access the sampled parameters and corresponding weights using: .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py :language: python :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 :py:meth:`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 :py:meth:`journal.get_parameters()`: .. code-block:: python {'parameter_1' : [[0.95],[0.97]], 'parameter_2': [[0.98,1.03],[1.06,0.92]]} -These are samples at the final step of ABC algorithm. If you want samples from the earlier steps you can get a Python dictionary for that step by using: +These are samples at the final step of ABC algorithm. If you want samples from the earlier steps of a sequential algorithm you can get a Python dictionary for that step by using: .. code-block:: python @@ -56,7 +58,18 @@ algorithm that created it: :lines: 85 :dedent: 4 -Finally, you can plot the inferred posterior distribution of the parameters in the following way: +And certainly, a journal can easily be saved to and loaded from disk: + +.. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py + :language: python + :lines: 91, 94 + :dedent: 4 + +Posterior plots and diagnostics +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +You can plot the inferred posterior distribution of the parameters in the following way: .. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py :language: python @@ -91,9 +104,39 @@ Instead, for journals generated by MCMC, we provide way to plot the traceplot fo -And certainly, a journal can easily be saved to and loaded from disk: +Posterior resampling and predictive check +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +In some cases, you may want to resample (for instance, bootstrapping or subsampling) the posterior samples stored in a +Journal, by tacking into account the posterior weights. +This can be done using the :py:meth:`resample()` method. Behind the scenes, +this uses the numpy.random.choice method, and it inherits arguments from it. It allows to do different things, +for instance: + + +* if the set of posterior samples (weighted or unweighted) is too large, you can obtained a subsampled (without replacement) set by doing: + +.. code-block:: python + + new_journal = journal.resample(n_samples=100, replace=False) + + +* Alternatively, if the used algorithm returns weighted posterior samples, you may want instead an unweighted set of samples obtained by sampling with replacement (commonly called bootstrapping); this can be done with the following line (where the number of required bootstrapped samples in the new journal is unspecified and therefore corresponding to the number of samples in the old ``journal``): + +.. code-block:: python + + new_journal = journal.resample() + + +Finally, in some cases you may want to generate simulations from the model for parameter values sampled from the posterior, +for instance in order to check similarity with the original observation (predictive check). ABCpy provides the +:py:class:`output.GenerateFromJournal` to do that. This class needs to be instanstiated +by providing to it the model and the backend which you want to use for the simulation; then, you can pass a Journal as argument to the +:py:meth:`generate()` method in order to generate simulations from the +posterior samples contained there: + +.. code-block:: python + + generate_from_journal = GenerateFromJournal([model], backend=backend) + parameters, simulations, normalized_weights = generate_from_journal.generate(journal) -.. literalinclude:: ../../examples/backends/dummy/pmcabc_gaussian.py - :language: python - :lines: 91, 94 - :dedent: 4 diff --git a/tests/output_tests.py b/tests/output_tests.py index 4771a20..0f1f154 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -6,7 +6,7 @@ from abcpy.continuousmodels import Normal from abcpy.continuousmodels import Uniform from abcpy.inferences import DrawFromPrior -from abcpy.output import Journal +from abcpy.output import Journal, GenerateFromJournal class JournalTests(unittest.TestCase): @@ -283,5 +283,52 @@ def test_resample(self): original_journal.resample(replace=False, n_samples=200) +class GenerateFromJournalTests(unittest.TestCase): + def setUp(self): + # setup backend + dummy = 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]) + + # define a stupid uniform model now + self.model2 = Uniform([[0], [10]]) + + self.sampler = DrawFromPrior([self.model], dummy, seed=1) + self.original_journal = self.sampler.sample(100) + + self.generate_from_journal = GenerateFromJournal([self.model], dummy, seed=2) + self.generate_from_journal_2 = GenerateFromJournal([self.model2], dummy, seed=2) + + # expected mean values from bootstrapped samples: + self.mu_mean = -0.2050921750330999 + self.sigma_mean = 5.178647189918053 + # expected mean values from subsampled samples: + self.mu_mean_2 = -0.021275259024241676 + self.sigma_mean_2 = 5.672004487129107 + + def test_generate(self): + # sample single simulation for each par value + parameters, simulations, normalized_weights = self.generate_from_journal.generate(journal=self.original_journal) + self.assertEqual(parameters.shape, (100, 2)) + self.assertEqual(simulations.shape, (100, 1, 1)) + self.assertEqual(normalized_weights.shape, (100,)) + + # sample multiple simulations for each par value + parameters, simulations, normalized_weights = self.generate_from_journal.generate(self.original_journal, + n_samples_per_param=3) + self.assertEqual(parameters.shape, (100, 2)) + self.assertEqual(simulations.shape, (10, 3, 1)) + self.assertEqual(normalized_weights.shape, (100,)) + + def test_errors(self): + # check whether using a different model leads to errors: + with self.assertRaises(RuntimeError): + self.generate_from_journal_2.generate(self.original_journal) + + if __name__ == '__main__': unittest.main() From 7935558ef9442aabd1dc59fd11cc5813ab8d17e1 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Wed, 21 Jul 2021 18:40:11 +0200 Subject: [PATCH 20/34] Small fix --- tests/output_tests.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/output_tests.py b/tests/output_tests.py index c1686d6..6e2547e 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -347,9 +347,10 @@ def test_generate(self): # sample multiple simulations for each par value parameters, simulations, normalized_weights = self.generate_from_journal.generate(self.original_journal, - n_samples_per_param=3) + n_samples_per_param=3, + iteration=-1) self.assertEqual(parameters.shape, (100, 2)) - self.assertEqual(simulations.shape, (10, 3, 1)) + self.assertEqual(simulations.shape, (100, 3, 1)) self.assertEqual(normalized_weights.shape, (100,)) def test_errors(self): From 9f798ae13490ded4f1b50086a98322c393be5e77 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Mon, 23 Aug 2021 14:48:43 +0100 Subject: [PATCH 21/34] Add way to normalize statistics based on a set of reference simulations --- abcpy/statistics.py | 295 +++++++++++++----- ...stics_learning_DrawFromPrior_reload_NNs.py | 13 +- tests/statistics_tests.py | 80 ++++- 3 files changed, 298 insertions(+), 90 deletions(-) diff --git a/abcpy/statistics.py b/abcpy/statistics.py index fdde773..df28a03 100644 --- a/abcpy/statistics.py +++ b/abcpy/statistics.py @@ -19,18 +19,26 @@ class Statistics(metaclass=ABCMeta): The base class also implements a polynomial expansion with cross-product terms that can be used to get desired polynomial expansion of the calculated statistics. - """ - @abstractmethod - def __init__(self, degree=1, cross=False, previous_statistics=None): - """Constructor that must be overwritten by the sub-class. - - The constructor of a sub-class must accept arguments for the polynomial - expansion after extraction of the summary statistics, one has to define - the degree of polynomial expansion and cross, indicating whether cross-prodcut - terms are included. - + def __init__(self, degree=1, cross=False, reference_simulations=None, previous_statistics=None): + """ + Initialization of the parent class. All sub-classes must call this at the end of their __init__, + as it takes care of initializing the correct attributes to self for the other methods to work. + + `degree` and `cross` specify the polynomial expansion you want to apply to the statistics. + + If `reference_simulations` are provided, the standard deviation of the different statistics on the set + of reference simulations is computed and stored; these will then be used to rescale + the statistics for each new simulation or observation. + If no set of reference simulations are provided, then this is not done. + + `previous_statistics` allows different Statistics object to be pipelined. Specifically, if the final + statistic to be used is determined by the + composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it + is sufficient to call the `statistics` method of the second one, and that will automatically apply both + transformations. + Parameters ---------- degree: integer, optional @@ -38,14 +46,27 @@ def __init__(self, degree=1, cross=False, previous_statistics=None): cross: boolean, optional Defines whether to include the cross-product terms. The default value is True, meaning the cross product term is included. - previous_statistics: Statistics class, optional + reference_simulations: array, optional + A numpy array with shape (n_samples, output_size) containing a set of reference simulations. If provided, + statistics are computed at initialization for all reference simulations, and the standard deviation of the + different statistics is extracted. The standard deviation is then used to standardize the summary + statistics each time they are compute on a new observation or simulation. Defaults to None, in which case + standardization is not applied. + previous_statistics: abcpy.statistics.Statistics, optional It allows pipelining of Statistics. Specifically, if the final statistic to be used is determined by the composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it is sufficient to call the `statistics` method of the second one, and that will automatically apply both transformations. """ - raise NotImplementedError + self.degree = degree + self.cross = cross + self.previous_statistics = previous_statistics + if reference_simulations is not None: + training_statistics = self.statistics( + [reference_simulations[i] for i in range(reference_simulations.shape[0])]) + self.std_statistics = np.std(training_statistics, axis=0) + # we store this and use it to rescale the statistics @abstractmethod def statistics(self, data: object) -> object: @@ -53,6 +74,24 @@ def statistics(self, data: object) -> object: data set data. It is assumed that data is a list of n same type elements(eg., The data can be a list containing n timeseries, n graphs or n np.ndarray). + All statistics implementation should follow this structure: + + >>> # need to call this first which takes care of calling the + >>> # previous statistics if that is defined and of properly + >>> # formatting data + >>> data = self._preprocess(data) + >>> + >>> # !!! here do all the processing on the statistics (data) !!! + >>> + >>> # Expand the data with polynomial expansion + >>> result = self._polynomial_expansion(data) + >>> + >>> # now call the _rescale function which automatically rescales + >>> # the different statistics using the standard + >>> # deviation of them on the training set provided at initialization. + >>> result = self._rescale(result) + + Parameters ---------- data: python list @@ -68,7 +107,9 @@ def statistics(self, data: object) -> object: def _polynomial_expansion(self, summary_statistics): """Helper function that does the polynomial expansion and includes cross-product - terms of summary_statistics, already calculated summary statistics. + terms of summary_statistics, already calculated summary statistics. It is tipically called in the `statistics` + method of a `Statistics` class, after the statistics have been computed from data but before the statistics + are (optionally) rescaled. Parameters ---------- @@ -93,15 +134,78 @@ def _polynomial_expansion(self, summary_statistics): result = np.column_stack((result, np.power(summary_statistics, ind))) # Include the cross-product term - if self.cross == True and summary_statistics.shape[1] > 1: + if self.cross and summary_statistics.shape[1] > 1: # Convert to a matrix for ind1 in range(0, summary_statistics.shape[1]): for ind2 in range(ind1 + 1, summary_statistics.shape[1]): result = np.column_stack((result, summary_statistics[:, ind1] * summary_statistics[:, ind2])) return result - def _check_and_transform_input(self, data): + def _rescale(self, result): + """Rescales the final summary statistics using the standard deviations computed at initialization on the set of + reference simulations. If that was not done, no rescaling is done. + + Parameters + ---------- + result: numpy.ndarray + Final summary statistics (after polynomial expansion) + + Returns + ------- + numpy.ndarray + Rescaled summary statistics, with the same shape as the input. """ + if hasattr(self, "std_statistics"): + if result.shape[-1] != self.std_statistics.shape[-1]: + raise RuntimeError("The size of the statistics is not the same as the stored standard deviations for " + "rescaling! Please check that you initialized the statistics with the correct set " + "of reference samples.") + + result = result / self.std_statistics + + return result + + def _preprocess(self, data): + """Utility which needs to be called at the beginning of the `statistics` method for all `Statistics` classes. + It takes care of calling the `previous_statistics` if that is available (pipelining) + and of correctly formatting the data. + + Parameters + ---------- + data: python list + Contains n data sets with length p. + + Returns + ------- + numpy.ndarray + Formatted statistics after pipelining. + """ + + # pipeline: first call the previous statistics: + if self.previous_statistics is not None: + data = self.previous_statistics.statistics(data) + # the first of the statistics need to take list as input, in order to match the API. Then actually the + # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the + # following code needs to be called only if the self statistic is the first, i.e. it does not have a + # previous_statistic element. + else: + data = self._check_and_transform_input(data) + + return data + + def _check_and_transform_input(self, data): + """ Formats the input in the correct way for computing summary statistics; specifically takes as input a + list and returns a numpy.ndarray. + + Parameters + ---------- + data: python list + Contains n data sets with length p. + + Returns + ------- + numpy.ndarray + Formatted statistics after pipelining. """ if isinstance(data, list): if np.array(data).shape == (len(data),): @@ -124,26 +228,6 @@ class Identity(Statistics): expansion term and cross*nchoosek(p,2) many cross-product terms are calculated. """ - def __init__(self, degree=1, cross=False, previous_statistics=None): - """ - - Parameters - ---------- - degree : integer, optional - Of polynomial expansion. The default value is 2 meaning second order polynomial expansion. - cross : boolean, optional - Defines whether to include the cross-product terms. The default value is True, meaning the cross product term - is included. - previous_statistics : Statistics class, optional - It allows pipelining of Statistics. Specifically, if the final statistic to be used is determined by the - composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it - is sufficient to call the `statistics` method of the second one, and that will automatically apply both - transformations. - """ - self.degree = degree - self.cross = cross - self.previous_statistics = previous_statistics - def statistics(self, data): """ Parameters @@ -157,19 +241,17 @@ def statistics(self, data): (p+degree*p+cross*nchoosek(p,2)) statistics are calculated. """ - # pipeline: first call the previous statistics: - if self.previous_statistics is not None: - data = self.previous_statistics.statistics(data) - # the first of the statistics need to take list as input, in order to match the API. Then actually the - # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the - # following code needs to be called only if the self statistic is the first, i.e. it does not have a - # previous_statistic element. - else: - data = self._check_and_transform_input(data) + # need to call this first which takes care of calling the previous statistics if that is defined and of properly + # formatting data + data = self._preprocess(data) # Expand the data with polynomial expansion result = self._polynomial_expansion(data) + # now call the _rescale function which automatically rescales the different statistics using the standard + # deviation of them on the training set provided at initialization. + result = self._rescale(result) + return result @@ -178,8 +260,21 @@ class LinearTransformation(Statistics): an additional polynomial expansion step. """ - def __init__(self, coefficients, degree=1, cross=False, previous_statistics=None): + def __init__(self, coefficients, degree=1, cross=False, reference_simulations=None, previous_statistics=None): """ + `degree` and `cross` specify the polynomial expansion you want to apply to the statistics. + + If `reference_simulations` are provided, the standard deviation of the different statistics on the set + of reference simulations is computed and stored; these will then be used to rescale + the statistics for each new simulation or observation. + If no set of reference simulations are provided, then this is not done. + + `previous_statistics` allows different Statistics object to be pipelined. Specifically, if the final + statistic to be used is determined by the + composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it + is sufficient to call the `statistics` method of the second one, and that will automatically apply both + transformations. + Parameters ---------- coefficients: coefficients is a matrix with size d x p, where d is the dimension of the summary statistic that @@ -190,16 +285,21 @@ def __init__(self, coefficients, degree=1, cross=False, previous_statistics=None cross : boolean, optional Defines whether to include the cross-product terms. The default value is True, meaning the cross product term is included. - previous_statistics : Statistics class, optional + reference_simulations: array, optional + A numpy array with shape (n_samples, output_size) containing a set of reference simulations. If provided, + statistics are computed at initialization for all reference simulations, and the standard deviation of the + different statistics is extracted. The standard deviation is then used to standardize the summary + statistics each time they are compute on a new observation or simulation. Defaults to None, in which case + standardization is not applied. + previous_statistics : abcpy.statistics.Statistics, optional It allows pipelining of Statistics. Specifically, if the final statistic to be used is determined by the composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it is sufficient to call the `statistics` method of the second one, and that will automatically apply both transformations. """ self.coefficients = coefficients - self.degree = degree - self.cross = cross - self.previous_statistics = previous_statistics + + super(LinearTransformation, self).__init__(degree, cross, reference_simulations, previous_statistics) def statistics(self, data): """ @@ -215,23 +315,21 @@ def statistics(self, data): calculated. """ - # pipeline: first call the previous statistics: - if self.previous_statistics is not None: - data = self.previous_statistics.statistics(data) - # the first of the statistics need to take list as input, in order to match the API. Then actually the - # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the - # following code needs to be called only if the self statistic is the first, i.e. it does not have a - # previous_statistic element. - else: - data = self._check_and_transform_input(data) + # need to call this first which takes care of calling the previous statistics if that is defined and of properly + # formatting data + data = self._preprocess(data) # Apply now the linear transformation if not data.shape[1] == self.coefficients.shape[0]: raise ValueError('Mismatch in dimension of summary statistics and coefficients') - result = np.dot(data, self.coefficients) + data = np.dot(data, self.coefficients) # Expand the data with polynomial expansion - result = self._polynomial_expansion(result) + result = self._polynomial_expansion(data) + + # now call the _rescale function which automatically rescales the different statistics using the standard + # deviation of them on the training set provided at initialization. + result = self._rescale(result) return result @@ -244,14 +342,39 @@ class NeuralEmbedding(Statistics): Pytorch is required for this part to work. """ - def __init__(self, net, previous_statistics=None): # are these default values OK? + def __init__(self, net, degree=1, cross=False, reference_simulations=None, previous_statistics=None): + """ + `degree` and `cross` specify the polynomial expansion you want to apply to the statistics. + + If `reference_simulations` are provided, the standard deviation of the different statistics on the set + of reference simulations is computed and stored; these will then be used to rescale + the statistics for each new simulation or observation. + If no set of reference simulations are provided, then this is not done. + + `previous_statistics` allows different Statistics object to be pipelined. Specifically, if the final + statistic to be used is determined by the + composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it + is sufficient to call the `statistics` method of the second one, and that will automatically apply both + transformations. + Parameters ---------- net : torch.nn object the embedding neural network. The input size of the neural network must coincide with the size of each of the datapoints. - previous_statistics : Statistics class, optional + degree: integer, optional + Of polynomial expansion. The default value is 2 meaning second order polynomial expansion. + cross: boolean, optional + Defines whether to include the cross-product terms. The default value is True, meaning the cross product term + is included. + reference_simulations: array, optional + A numpy array with shape (n_samples, output_size) containing a set of reference simulations. If provided, + statistics are computed at initialization for all reference simulations, and the standard deviation of the + different statistics is extracted. The standard deviation is then used to standardize the summary + statistics each time they are compute on a new observation or simulation. Defaults to None, in which case + standardization is not applied. + previous_statistics: abcpy.statistics.Statistics, optional It allows pipelining of Statistics. Specifically, if the final statistic to be used is determined by the composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it is sufficient to call the `statistics` method of the second one, and that will automatically apply both @@ -263,11 +386,14 @@ def __init__(self, net, previous_statistics=None): # are these default values O "neural networks. Please install it. ".format(self.__class__.__name__)) self.net = net - self.previous_statistics = previous_statistics + + # init of super class + super(NeuralEmbedding, self).__init__(degree, cross, reference_simulations, previous_statistics) @classmethod 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): + output_size=None, hidden_sizes=None, degree=1, cross=False, reference_simulations=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. @@ -311,7 +437,18 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, path_to_scaler=Non [5,7,5] denotes 3 hidden layers with correspondingly 5,7,5 neurons). In case this parameter is not provided, the hidden sizes are determined from the input and output sizes as determined in abcpy.NN_utilities.networks.DefaultNN. Note that this must not be provided together with `network_class`. - previous_statistics : Statistics class, optional + degree: integer, optional + Of polynomial expansion. The default value is 2 meaning second order polynomial expansion. + cross: boolean, optional + Defines whether to include the cross-product terms. The default value is True, meaning the cross product term + is included. + reference_simulations: array, optional + A numpy array with shape (n_samples, output_size) containing a set of reference simulations. If provided, + statistics are computed at initialization for all reference simulations, and the standard deviation of the + different statistics is extracted. The standard deviation is then used to standardize the summary + statistics each time they are compute on a new observation or simulation. Defaults to None, in which case + standardization is not applied. + previous_statistics : abcpy.statistics.Statistics, optional It allows pipelining of Statistics. Specifically, if the final statistic to be used is determined by the composition of two Statistics, you can pass the first here; then, whenever the final statistic is needed, it is sufficient to call the `statistics` method of the second one, and that will automatically apply both @@ -347,7 +484,8 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, path_to_scaler=Non f.close() net = ScalerAndNet(net, scaler) - statistic_object = cls(net, previous_statistics=previous_statistics) + statistic_object = cls(net, degree=degree, cross=cross, reference_simulations=reference_simulations, + previous_statistics=previous_statistics) return statistic_object @@ -384,21 +522,16 @@ def statistics(self, data): ---------- data: python list Contains n data sets with length p. + Returns ------- numpy.ndarray the statistics computed by applying the neural network. """ - # pipeline: first call the previous statistics: - if self.previous_statistics is not None: - data = self.previous_statistics.statistics(data) - # the first of the statistics need to take list as input, in order to match the API. Then actually the - # transformations work on np.arrays. In fact the first statistic transforms the list to array. Therefore, the - # following code needs to be called only if the self statistic is the first, i.e. it does not have a - # previous_statistic element. - else: - data = self._check_and_transform_input(data) + # need to call this first which takes care of calling the previous statistics if that is defined and of properly + # formatting data + data = self._preprocess(data) data = torch.from_numpy(data.astype("float32")) @@ -407,6 +540,14 @@ def statistics(self, data): data = data.cuda() # simply apply the network transformation. - result = self.net(data).cpu().detach().numpy() + data = self.net(data).cpu().detach().numpy() + data = np.array(data) + + # Expand the data with polynomial expansion + result = self._polynomial_expansion(data) - return np.array(result) + # now call the _rescale function which automatically rescales the different statistics using the standard + # deviation of them on the training set provided at initialization. + result = self._rescale(result) + + return result diff --git a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py index 0139a7f..03cd19b 100644 --- a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py +++ b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py @@ -69,13 +69,13 @@ def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level= logging.info("semiNN") from abcpy.statisticslearning import SemiautomaticNN, TripletDistanceLearning semiNN = SemiautomaticNN([height], identity, backend=backend, parameters=parameters, - simulations=simulations, parameters_val=parameters_val, simulations_val=simulations, + simulations=simulations, parameters_val=parameters_val, simulations_val=simulations_val, early_stopping=True, # early stopping seed=1, n_epochs=10, scale_samples=False) logging.info("triplet") triplet = TripletDistanceLearning([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, - simulations_val=simulations, + simulations_val=simulations_val, early_stopping=True, # early stopping seed=1, n_epochs=10, scale_samples=True) @@ -98,7 +98,14 @@ def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level= learned_triplet_stat_loaded = NeuralEmbedding.fromFile("triplet_net.pth", input_size=1, output_size=2, path_to_scaler="scaler.pkl") - # 4) perform inference + # 4) you can optionally rescale the different summary statistics be their standard deviation on a reference dataset + # of simulations. To do this, it is enough to pass at initialization the reference dataset, and the rescaling will + # be applied every time the statistics is computed on some simulation or observation. + learned_triplet_stat_loaded = NeuralEmbedding.fromFile("triplet_net.pth", input_size=1, output_size=2, + path_to_scaler="scaler.pkl", + reference_simulations=simulations_val) + + # 5) perform inference # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(learned_seminn_stat_loaded) diff --git a/tests/statistics_tests.py b/tests/statistics_tests.py index 5628920..6566f86 100644 --- a/tests/statistics_tests.py +++ b/tests/statistics_tests.py @@ -11,13 +11,31 @@ else: has_torch = True from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet + from abcpy.inferences import DrawFromPrior + from abcpy.continuousmodels import Uniform, Normal + from abcpy.backends import BackendDummy class IdentityTests(unittest.TestCase): def setUp(self): - self.stat_calc = Identity(degree=1, cross=0) + self.stat_calc = Identity(degree=1, cross=False) self.stat_calc_pipeline = Identity(degree=2, cross=False, previous_statistics=self.stat_calc) + # try now the statistics rescaling option: + 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]) + + sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) + reference_parameters, reference_simulations = sampler.sample_par_sim_pairs(30, 1) + reference_simulations = reference_simulations.reshape(reference_simulations.shape[0], + reference_simulations.shape[2]) + reference_simulations_double = np.concatenate([reference_simulations, reference_simulations], axis=1) + + self.stat_calc_rescaling = Identity(reference_simulations=reference_simulations_double) + self.stat_calc_rescaling_2 = Identity(reference_simulations=reference_simulations) + def test_statistics(self): self.assertRaises(TypeError, self.stat_calc.statistics, 3.4) vec1 = np.array([1, 2]) @@ -26,22 +44,27 @@ def test_statistics(self): self.assertTrue((self.stat_calc.statistics([vec1, vec1]) == np.array([[vec1], [vec1]])).all()) self.assertTrue((self.stat_calc.statistics([vec2, vec2]) == np.array([[vec2], [vec2]])).all()) + self.assertTrue((self.stat_calc_rescaling.statistics([vec1]) != self.stat_calc.statistics([vec1])).all()) + self.assertTrue((self.stat_calc_rescaling_2.statistics([vec2]) != self.stat_calc.statistics([vec2])).all()) + + self.assertRaises(RuntimeError, self.stat_calc_rescaling.statistics, [vec2]) + def test_polynomial_expansion(self): # Checks whether wrong input type produces error message self.assertRaises(TypeError, self.stat_calc._polynomial_expansion, 3.4) a = [np.array([0, 2]), np.array([2, 1])] # test cross-product part - self.stat_calc = Identity(degree=2, cross=1) + self.stat_calc = Identity(degree=2, cross=True) self.assertTrue((self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0], [2, 1, 4, 1, 2]])).all()) # When a tuple a = [np.array([0, 2])] - self.stat_calc = Identity(degree=2, cross=1) + self.stat_calc = Identity(degree=2, cross=True) self.assertTrue((self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0]])).all()) - self.stat_calc = Identity(degree=2, cross=0) + self.stat_calc = Identity(degree=2, cross=False) self.assertTrue((self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4]])).all()) a = list(np.array([2])) - self.stat_calc = Identity(degree=2, cross=1) + self.stat_calc = Identity(degree=2, cross=True) self.assertTrue((self.stat_calc.statistics(a) == np.array([[2, 4]])).all()) def test_pipeline(self): @@ -52,7 +75,21 @@ def test_pipeline(self): class LinearTransformationTests(unittest.TestCase): def setUp(self): self.coeff = np.array([[3, 4], [5, 6]]) - self.stat_calc = LinearTransformation(self.coeff, degree=1, cross=0) + self.stat_calc = LinearTransformation(self.coeff, degree=1, cross=False) + + # try now the statistics rescaling option: + 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]) + + sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) + reference_parameters, reference_simulations = sampler.sample_par_sim_pairs(30, 1) + reference_simulations = reference_simulations.reshape(reference_simulations.shape[0], + reference_simulations.shape[2]) + reference_simulations_double = np.concatenate([reference_simulations, reference_simulations], axis=1) + + self.stat_calc_rescaling = LinearTransformation(self.coeff, reference_simulations=reference_simulations_double) def test_statistics(self): self.assertRaises(TypeError, self.stat_calc.statistics, 3.4) @@ -63,23 +100,25 @@ def test_statistics(self): [np.dot(np.array([1, 2]), self.coeff), np.dot(np.array([1, 2]), self.coeff)])).all()) self.assertRaises(ValueError, self.stat_calc.statistics, [vec2]) + self.assertTrue((self.stat_calc_rescaling.statistics([vec1]) != self.stat_calc.statistics([vec1])).all()) + def test_polynomial_expansion(self): # Checks whether wrong input type produces error message self.assertRaises(TypeError, self.stat_calc._polynomial_expansion, 3.4) a = [np.array([0, 2]), np.array([2, 1])] # test cross-product part - self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=1) + self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=True) self.assertTrue((self.stat_calc.statistics(a) == np.array([[10, 12, 100, 144, 120], [11, 14, 121, 196, 154]])).all()) # When a tuple a = [np.array([0, 2])] - self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=1) + self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=True) self.assertTrue((self.stat_calc.statistics(a) == np.array([[10, 12, 100, 144, 120]])).all()) - self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=0) + self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=False) self.assertTrue((self.stat_calc.statistics(a) == np.array([[10, 12, 100, 144]])).all()) a = list(np.array([2])) - self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=1) + self.stat_calc = LinearTransformation(self.coeff, degree=2, cross=True) self.assertRaises(ValueError, self.stat_calc.statistics, a) @@ -90,6 +129,25 @@ def setUp(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) + # reference input and output + torch.random.manual_seed(1) + self.tensor = torch.randn(1, 2) + self.out = self.net(self.tensor) + + # try now the statistics rescaling option: + 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]) + + sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) + reference_parameters, reference_simulations = sampler.sample_par_sim_pairs(30, 1) + reference_simulations = reference_simulations.reshape(reference_simulations.shape[0], + reference_simulations.shape[2]) + + self.stat_calc_rescaling = NeuralEmbedding(self.net, reference_simulations=reference_simulations, + previous_statistics=Identity(degree=2)) + if not has_torch: self.assertRaises(ImportError, NeuralEmbedding, None) @@ -102,6 +160,8 @@ def test_statistics(self): self.assertTrue((self.stat_calc.statistics([vec1, vec1])).all()) self.assertRaises(RuntimeError, self.stat_calc.statistics, [vec2]) + self.assertTrue((self.stat_calc_rescaling.statistics([vec2])).all()) + def test_save_load(self): if has_torch: self.stat_calc.save_net("net.pth") From 3c24e743df0dc2e77beb82ae9110685307e69a47 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Mon, 23 Aug 2021 15:51:41 +0100 Subject: [PATCH 22/34] Fix docs --- doc/source/user_customization.rst | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/doc/source/user_customization.rst b/doc/source/user_customization.rst index 2063632..827cfa3 100644 --- a/doc/source/user_customization.rst +++ b/doc/source/user_customization.rst @@ -407,7 +407,7 @@ calculator should be provided. The following header conforms to this idea: .. literalinclude:: ../../abcpy/distances.py :language: python - :lines: 15,27-33 + :lines: 16,28-34 :dedent: 4 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 ` 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 @@ -416,14 +416,14 @@ compute it once and store it internally. At each call of the ``distance`` method .. literalinclude:: ../../abcpy/distances.py :language: python - :lines: 152-176 + :lines: 169-193 :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: 178-185 + :lines: 195-202 :dedent: 4 The newly defined distance class can be used in the same way as the already existing once. The complete example for this @@ -494,7 +494,7 @@ Let us now look at the implementation of the method: .. literalinclude:: ../../abcpy/perturbationkernel.py :language: python - :lines: 247-279 + :lines: 246-278 :dedent: 4 Some of the implemented inference algorithms weigh different sets of parameters differently. Therefore, if such weights @@ -523,7 +523,7 @@ Here the implementation for our kernel: .. literalinclude:: ../../abcpy/perturbationkernel.py :language: python - :lines: 281-329 + :lines: 280-328 :dedent: 4 The first line shows how you obtain the values of the parameters that your kernel should perturb. These values are @@ -540,7 +540,7 @@ This method is implemented as follows for the multivariate normal: .. literalinclude:: ../../abcpy/perturbationkernel.py :language: python - :lines: 331-358 + :lines: 330-357 :dedent: 4 We simply obtain the parameter values and covariance matrix for this kernel and calculate the probability density From 6e574ff04969cd03db3c0d782ecbaf449f11ea85 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Mon, 23 Aug 2021 11:35:34 +0100 Subject: [PATCH 23/34] Small fix to tests --- tests/statistics_tests.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/statistics_tests.py b/tests/statistics_tests.py index 6566f86..996aa49 100644 --- a/tests/statistics_tests.py +++ b/tests/statistics_tests.py @@ -2,6 +2,9 @@ import numpy as np +from abcpy.backends import BackendDummy +from abcpy.continuousmodels import Uniform, Normal +from abcpy.inferences import DrawFromPrior from abcpy.statistics import Identity, LinearTransformation, NeuralEmbedding try: @@ -11,9 +14,6 @@ else: has_torch = True from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet - from abcpy.inferences import DrawFromPrior - from abcpy.continuousmodels import Uniform, Normal - from abcpy.backends import BackendDummy class IdentityTests(unittest.TestCase): From 8ebb67d95077f0079f64afc87939274f22d21d07 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Tue, 24 Aug 2021 11:46:24 +0100 Subject: [PATCH 24/34] Refactor Bounded transformer --- abcpy/transformers.py | 107 +++++++++++++++++++++++++----------------- 1 file changed, 63 insertions(+), 44 deletions(-) diff --git a/abcpy/transformers.py b/abcpy/transformers.py index 38f9614..e344a9b 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -12,7 +12,7 @@ class BoundedVarTransformer: def __init__(self, lower_bound, upper_bound): - # upper and lower bounds can be both scalar or array-like with size the size of the variable + # upper and lower bounds need to be numpy arrays with size the size of the variable self.lower_bound = lower_bound self.upper_bound = upper_bound @@ -37,21 +37,69 @@ def __init__(self, lower_bound, upper_bound): def logit(x): return np.log(x) - np.log(1 - x) - def _check_data_in_bounds(self, x): - if np.any(x[self.lower_bounded_vars] <= self.lower_bound_lower_bounded): + def _check_data_in_bounds(self, X): + # Takes as input 1d or 2d arrays + X = np.atleast_2d(X) # convert to 2d if needed + if np.any(X[:, self.lower_bounded_vars] <= self.lower_bound_lower_bounded): raise RuntimeError("The provided data are out of the bounds.") - if (x[self.two_sided_bounded_vars] <= self.lower_bound[self.two_sided_bounded_vars]).any() or ( - x[self.two_sided_bounded_vars] >= self.upper_bound_two_sided).any(): + if (X[:, self.two_sided_bounded_vars] <= self.lower_bound[self.two_sided_bounded_vars]).any() or ( + X[:, self.two_sided_bounded_vars] >= self.upper_bound_two_sided).any(): raise RuntimeError("The provided data is out of the bounds.") - def _apply_nonlinear_transf(self, x): - # apply the different scalers to the different kind of variables: - x_transf = x.copy() - x_transf[self.lower_bounded_vars] = np.log(x[self.lower_bounded_vars] - self.lower_bound_lower_bounded) - x_transf[self.two_sided_bounded_vars] = self.logit( - (x[self.two_sided_bounded_vars] - self.lower_bound_two_sided) / ( + def _apply_nonlinear_transf(self, X): + # apply the different transformations to the different kind of variables. Takes as input 1d or 2d arrays + squeeze = len(X.shape) == 1 + X = np.atleast_2d(X) + X_transf = X.copy() + X_transf[:, self.lower_bounded_vars] = np.log(X[:, self.lower_bounded_vars] - self.lower_bound_lower_bounded) + X_transf[:, self.two_sided_bounded_vars] = self.logit( + (X[:, self.two_sided_bounded_vars] - self.lower_bound_two_sided) / ( self.upper_bound_two_sided - self.lower_bound_two_sided)) - return x_transf + return X_transf.squeeze() if squeeze else X_transf + + def _apply_inverse_nonlinear_transf(self, X): + # inverse transformation. Different trasformations applied to different kind of variables. + # Takes as input 1d or 2d arrays + squeeze = len(X.shape) == 1 + X = np.atleast_2d(X) + inv_X = X.copy() + inv_X[:, self.two_sided_bounded_vars] = (self.upper_bound_two_sided - self.lower_bound_two_sided) * np.exp( + X[:, self.two_sided_bounded_vars]) / (1 + np.exp( + X[:, self.two_sided_bounded_vars])) + self.lower_bound_two_sided + inv_X[:, self.lower_bounded_vars] = np.exp(X[:, self.lower_bounded_vars]) + self.lower_bound_lower_bounded + return inv_X.squeeze() if squeeze else inv_X + + def _jac_log_det(self, x): + # computes the jacobian log determinant. Takes as input arrays. + results = np.zeros_like(x) + results[self.two_sided_bounded_vars] = np.log( + (self.upper_bound_two_sided - self.lower_bound_two_sided).astype("float64") / ( + (x[self.two_sided_bounded_vars] - self.lower_bound_two_sided) * ( + self.upper_bound_two_sided - x[self.two_sided_bounded_vars]))) + results[self.lower_bounded_vars] = - np.log(x[self.lower_bounded_vars] - self.lower_bound_lower_bounded) + return np.sum(results) + + def _jac_log_det_inverse_transform(self, x): + # computes the log determinant of jacobian evaluated in the inverse transformation. Takes as input arrays. + results = np.zeros_like(x) + results[self.lower_bounded_vars] = - x[self.lower_bounded_vars] + # two sided: need some tricks to avoid numerical issues: + results[self.two_sided_bounded_vars] = - np.log( + self.upper_bound_two_sided - self.lower_bound_two_sided) + + indices = x[self.two_sided_bounded_vars] < 100 # for avoiding numerical overflow + res_b = np.copy(x)[self.two_sided_bounded_vars] + res_b[indices] = np.log(1 + np.exp(x[self.two_sided_bounded_vars][indices])) + results[self.two_sided_bounded_vars] += res_b + + indices = x[self.two_sided_bounded_vars] > - 100 # for avoiding numerical overflow + res_c = np.copy(- x)[self.two_sided_bounded_vars] + res_c[indices] = np.log(1 + np.exp(- x[self.two_sided_bounded_vars][indices])) + results[self.two_sided_bounded_vars] += res_c + + # res = res_b + res_c - res_a + + return np.sum(results) @staticmethod def _array_from_list(x): @@ -111,11 +159,7 @@ def inverse_transform(self, x): # now apply the inverse transform x_arr = self._array_from_list(x) - inv_x = x_arr.copy() - inv_x[self.two_sided_bounded_vars] = (self.upper_bound_two_sided - self.lower_bound_two_sided) * np.exp( - x_arr[self.two_sided_bounded_vars]) / (1 + np.exp( - x_arr[self.two_sided_bounded_vars])) + self.lower_bound_two_sided - inv_x[self.lower_bounded_vars] = np.exp(x_arr[self.lower_bounded_vars]) + self.lower_bound_lower_bounded + inv_x = self._apply_inverse_nonlinear_transf(x_arr) # convert back to the list structure: inv_x = self._list_from_array(inv_x, x) @@ -137,14 +181,7 @@ def jac_log_det(self, x): x = self._array_from_list(x) self._check_data_in_bounds(x) - results = np.zeros_like(x) - results[self.two_sided_bounded_vars] = np.log( - (self.upper_bound_two_sided - self.lower_bound_two_sided).astype("float64") / ( - (x[self.two_sided_bounded_vars] - self.lower_bound_two_sided) * ( - self.upper_bound_two_sided - x[self.two_sided_bounded_vars]))) - results[self.lower_bounded_vars] = - np.log(x[self.lower_bounded_vars] - self.lower_bound_lower_bounded) - - return np.sum(results) + return self._jac_log_det(x) def jac_log_det_inverse_transform(self, x): """Returns the log determinant of the Jacobian evaluated in the inverse transform: @@ -161,25 +198,7 @@ def jac_log_det_inverse_transform(self, x): """ x = self._array_from_list(x) - results = np.zeros_like(x) - results[self.lower_bounded_vars] = - x[self.lower_bounded_vars] - # two sided: need some tricks to avoid numerical issues: - results[self.two_sided_bounded_vars] = - np.log( - self.upper_bound_two_sided - self.lower_bound_two_sided) - - indices = x[self.two_sided_bounded_vars] < 100 # for avoiding numerical overflow - res_b = np.copy(x)[self.two_sided_bounded_vars] - res_b[indices] = np.log(1 + np.exp(x[self.two_sided_bounded_vars][indices])) - results[self.two_sided_bounded_vars] += res_b - - indices = x[self.two_sided_bounded_vars] > - 100 # for avoiding numerical overflow - res_c = np.copy(- x)[self.two_sided_bounded_vars] - res_c[indices] = np.log(1 + np.exp(- x[self.two_sided_bounded_vars][indices])) - results[self.two_sided_bounded_vars] += res_c - - # res = res_b + res_c - res_a - - return np.sum(results) + return self._jac_log_det_inverse_transform(x) class DummyTransformer: From 880c20290f7f80655e273310d2984a8b3ff0e3d6 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Mon, 23 Aug 2021 15:53:32 +0100 Subject: [PATCH 25/34] Add Exp Fam way to learn summary statistics --- Makefile | 1 + abcpy/NN_utilities/losses.py | 22 + abcpy/NN_utilities/networks.py | 219 +++++++- abcpy/NN_utilities/utilities.py | 111 ++++ abcpy/statistics.py | 22 +- abcpy/statisticslearning.py | 734 ++++++++++++++++++++++++-- abcpy/transformers.py | 213 +++++++- tests/NN_utilities_networks_tests.py | 75 +++ tests/NN_utilities_utilities_tests.py | 92 ++++ tests/statistics_tests.py | 39 +- tests/statisticslearning_tests.py | 195 ++++++- tests/transformers_tests.py | 117 +++- 12 files changed, 1755 insertions(+), 85 deletions(-) create mode 100644 tests/NN_utilities_networks_tests.py create mode 100644 tests/NN_utilities_utilities_tests.py diff --git a/Makefile b/Makefile index bd56734..b2e7491 100644 --- a/Makefile +++ b/Makefile @@ -28,6 +28,7 @@ unittest: python3 -m unittest discover -s tests -v -p "*_tests.py" || (echo "Error in standard unit tests."; exit 1) @# remove temporary files created during testing @if test -f net.pth; then rm net.pth; fi + @if test -f net_with_discard_wrapper.pth; then rm net_with_discard_wrapper.pth; fi @if test -f scaler.pkl; then rm scaler.pkl; fi @if test -f tmp.jnl; then rm tmp.jnl; fi @if test -f journal_tests_testfile.pkl; then rm journal_tests_testfile.pkl; fi diff --git a/abcpy/NN_utilities/losses.py b/abcpy/NN_utilities/losses.py index 4dc28cb..22a15c3 100644 --- a/abcpy/NN_utilities/losses.py +++ b/abcpy/NN_utilities/losses.py @@ -1,3 +1,4 @@ +import torch import torch.nn as nn import torch.nn.functional as F @@ -37,3 +38,24 @@ def forward(self, anchor, positive, negative, size_average=True): distance_negative = (anchor - negative).pow(2).sum(1) # .pow(.5) losses = F.relu(distance_positive - distance_negative + self.margin) return losses.mean() if size_average else losses.sum() + + +def Fisher_divergence_loss(first_der_t, second_der_t, eta, lam=0): + """lam is the regularization parameter of the Kingma & LeCun (2010) regularization""" + inner_prod_second_der_eta = torch.bmm(second_der_t, eta.unsqueeze(-1)) # this is used twice + + if lam == 0: + return sum( + (0.5 * torch.bmm(first_der_t, eta.unsqueeze(-1)) ** 2 + inner_prod_second_der_eta).view(-1)) + else: + return sum( + (0.5 * torch.bmm(first_der_t, eta.unsqueeze(-1)) ** 2 + + inner_prod_second_der_eta + lam * inner_prod_second_der_eta ** 2).view(-1)) + + +def Fisher_divergence_loss_with_c_x(first_der_t, second_der_t, eta, lam=0): + # this enables to use the term c(x) in the approximating family, ie a term that depends only on x and not on theta. + new_eta = torch.cat((eta, torch.ones(eta.shape[0], 1).to(eta)), + dim=1) # the one tensor need to be on same device as eta. + # then call the other loss function with this new_eta: + return Fisher_divergence_loss(first_der_t, second_der_t, new_eta, lam=lam) diff --git a/abcpy/NN_utilities/networks.py b/abcpy/NN_utilities/networks.py index 556a33d..ebbd4a5 100644 --- a/abcpy/NN_utilities/networks.py +++ b/abcpy/NN_utilities/networks.py @@ -1,6 +1,7 @@ import torch import torch.nn as nn import torch.nn.functional as F +from torch.autograd import grad class SiameseNet(nn.Module): @@ -42,7 +43,8 @@ def get_embedding(self, x): return self.embedding_net(x) -def createDefaultNN(input_size, output_size, hidden_sizes=None, nonlinearity=None): +def createDefaultNN(input_size, output_size, hidden_sizes=None, nonlinearity=None, batch_norm_last_layer=False, + batch_norm_last_layer_momentum=0.1): """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 in a heuristic way, see below). @@ -55,6 +57,12 @@ def createDefaultNN(input_size, output_size, hidden_sizes=None, nonlinearity=Non If hidden_sizes is None, three hidden layers are used with the following sizes: ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]`` + + Note that the nonlinearity here is as an object or a functional, not a class, eg: + nonlinearity = nn.Softplus() + or: + nonlinearity = nn.functional.softplus + """ class DefaultNN(nn.Module): @@ -85,27 +93,202 @@ def __init__(self): 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) + # define the batch_norm: + if batch_norm_last_layer: + self.bn_out = nn.BatchNorm1d(output_size, affine=False, momentum=batch_norm_last_layer_momentum) + def forward(self, x): + + if nonlinearity is None: + nonlinearity_fcn = F.relu + else: + nonlinearity_fcn = nonlinearity + if not hasattr(self, "fc_hidden"): # it means that hidden sizes was provided and the length of the list was 0 return self.fc_in(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 = nonlinearity_fcn(self.fc_in(x)) + for i in range(len(self.fc_hidden)): + x = nonlinearity_fcn(self.fc_hidden[i](x)) x = self.fc_out(x) + if batch_norm_last_layer: + x = self.bn_out(x) + return x return DefaultNN +def createDefaultNNWithDerivatives(input_size, output_size, hidden_sizes=None, nonlinearity=None, + first_derivative_only=False): + """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. This neural network is capable of computing the first and second derivatives of output with respect to + input along with the forward pass. + + All layers in this neural network are linear. + + >>> createDefaultNN(input_size, output_size)() + + as the function returns a class, and () is needed to instantiate an object. + + If hidden_sizes is None, three hidden layers are used with the following sizes: + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]`` + + Note that the nonlinearity here is passed as a class, not an object, eg: + nonlinearity = nn.Softplus + """ + + if nonlinearity in [torch.nn.Softsign, torch.nn.Tanhshrink]: + raise RuntimeError("The implementation of forward derivatives does not work with Tanhshrink and " + "Softsign nonlinearities.") + + class DefaultNNWithDerivatives(nn.Module): + """Neural network class with sizes determined by the upper level variables.""" + + def __init__(self): + super(DefaultNNWithDerivatives, self).__init__() + # put some fully connected layers: + + if nonlinearity is None: # default nonlinearity + non_linearity = nn.ReLU + else: + non_linearity = nonlinearity # need to change name otherwise it gives Error + + if hidden_sizes is not None and len(hidden_sizes) == 0: + # it is effectively a linear network + self.fc_in = nn.Linear(input_size, output_size) + + else: + if hidden_sizes is None: + # then set some default values for the hidden layers sizes; is this parametrization reasonable? + hidden_sizes_list = [int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), + int(output_size * 5)] + + else: + hidden_sizes_list = hidden_sizes + + self.fc_in = nn.Linear(input_size, hidden_sizes_list[0]) + self.nonlinearity_in = non_linearity() + + # define now the hidden layers + self.fc_hidden = nn.ModuleList() + self.nonlinearities_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.nonlinearities_hidden.append(non_linearity()) + self.fc_out = nn.Linear(hidden_sizes_list[-1], output_size) + + def forward(self, x): + + if not hasattr(self, + "fc_hidden"): # it means that hidden sizes was provided and the length of the list was 0, ie the + return self.fc_in(x) + + x = self.fc_in(x) + x1 = self.nonlinearity_in(x) + + for i in range(len(self.fc_hidden)): + x = self.fc_hidden[i](x1) + x1 = self.nonlinearities_hidden[i](x) + + x = self.fc_out(x1) + + return x + + def forward_and_derivatives(self, x): + + # initialize the derivatives: + f = self.fc_in.weight.unsqueeze(0).repeat(x.shape[0], 1, 1).transpose(2, 1).transpose(0, + 1) # one for each element of the batch + if not first_derivative_only: + s = torch.zeros_like(f) + + if not hasattr(self, "fc_hidden"): + # it means that hidden sizes was provided and the length of the list was 0, ie the net is a single layer. + if first_derivative_only: + return self.fc_in(x), f.transpose(0, 1) + else: + return self.fc_in(x), f.transpose(0, 1), s.transpose(0, 1) + + x = self.fc_in(x) + x1 = self.nonlinearity_in(x) + + for i in range(len(self.fc_hidden)): + z = x1.grad_fn(torch.ones_like(x1)) # here we repeat some computation from the above line + # z = grad(x1, x, torch.ones_like(x1), create_graph=True)[0] # here we repeat some computation from the above line + # you need to update first the second derivative, as you need the first derivative at previous layer + if not first_derivative_only: + s = z * s + grad(z, x, torch.ones_like(z), retain_graph=True)[0] * f ** 2 + f = z * f + f = F.linear(f, self.fc_hidden[i].weight) + if not first_derivative_only: + s = F.linear(s, self.fc_hidden[i].weight) + + x = self.fc_hidden[i](x1) + x1 = self.nonlinearities_hidden[i](x) + + z = x1.grad_fn(torch.ones_like(x1)) # here we repeat some computation from the above line + # z = grad(x1, x, torch.ones_like(x1), create_graph=True)[0] # here we repeat some computation from the above line + # you need to update first the second derivative, as you need the first derivative at previous layer + if not first_derivative_only: + s = z * s + grad(z, x, torch.ones_like(z), retain_graph=True)[0] * f ** 2 + f = z * f + f = F.linear(f, self.fc_out.weight) + if not first_derivative_only: + s = F.linear(s, self.fc_out.weight) + + x = self.fc_out(x1) + + if first_derivative_only: + return x, f.transpose(0, 1) + else: + return x, f.transpose(0, 1), s.transpose(0, 1) + + def forward_and_full_derivatives(self, x): + """This computes jacobian and full Hessian matrix""" + + # initialize the derivatives (one for each element of the batch) + f = self.fc_in.weight.unsqueeze(0).repeat(x.shape[0], 1, 1).transpose(2, 1).transpose(0, 1) + H = torch.zeros((f.shape[0], *f.shape)).to(f) # hessian has an additional dimension wrt f + + if not hasattr(self, "fc_hidden"): + # it means that hidden sizes was provided and the length of the list was 0, ie the net is a single layer + return self.fc_in(x), f.transpose(0, 1), H.transpose(0, 2) + + x = self.fc_in(x) + x1 = self.nonlinearity_in(x) + + for i in range(len(self.fc_hidden)): + z = x1.grad_fn(torch.ones_like(x1)) # here we repeat some computation from the above line + # print("H", H.shape, "z", z.shape, "z'", grad(z, x, torch.ones_like(z), retain_graph=True)[0].shape, "f", f.shape) + # z = grad(x1, x, torch.ones_like(x1), create_graph=True)[0] # here we repeat some computation from the above line + # you need to update first the second derivative, as you need the first derivative at previous layer + H = z * H + grad(z, x, torch.ones_like(z), retain_graph=True)[0] * torch.einsum('ibo,jbo->ijbo', f, f) + f = z * f + f = F.linear(f, self.fc_hidden[i].weight) + H = F.linear(H, self.fc_hidden[i].weight) + + x = self.fc_hidden[i](x1) + x1 = self.nonlinearities_hidden[i](x) + + z = x1.grad_fn(torch.ones_like(x1)) # here we repeat some computation from the above line + # z = grad(x1, x, torch.ones_like(x1), create_graph=True)[0] # here we repeat some computation from the above line + # you need to update first the second derivative, as you need the first derivative at previous layer + H = z * H + grad(z, x, torch.ones_like(z), retain_graph=True)[0] * torch.einsum('ibo,jbo->ijbo', f, f) + f = z * f + f = F.linear(f, self.fc_out.weight) + H = F.linear(H, self.fc_out.weight) + x = self.fc_out(x1) + + return x, f.transpose(0, 1), H.transpose(0, 2) + + return DefaultNNWithDerivatives + + 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.""" @@ -118,3 +301,21 @@ def __init__(self, net, 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) + + +class DiscardLastOutputNet(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. Next, the """ + + def __init__(self, net): + super().__init__() + self.net = net + + def forward(self, x): + x = self.net(x) + if len(x.shape) == 1: + return x[0:-1] + if len(x.shape) == 2: + return x[:, 0:-1] + if len(x.shape) == 3: + return x[:, :, 0:-1] diff --git a/abcpy/NN_utilities/utilities.py b/abcpy/NN_utilities/utilities.py index 61a07d9..c50c4e7 100644 --- a/abcpy/NN_utilities/utilities.py +++ b/abcpy/NN_utilities/utilities.py @@ -6,6 +6,8 @@ has_torch = True import logging +from functools import reduce +from operator import mul import numpy as np @@ -54,3 +56,112 @@ def load_net(path, network_class, *network_args, **network_kwargs): 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. + + +def jacobian(input, output, diffable=True): + ''' + Returns the Jacobian matrix (batch x in_size x out_size) of the function that produced the output evaluated at the + input + + From https://github.com/mwcvitkovic/MASS-Learning/blob/master/models/utils.py + + Important: need to use diffable=True in order for the training routines based on these to work! + + ''' + assert len(output.shape) == 2 + assert input.shape[0] == output.shape[0] + in_size = reduce(mul, list(input.shape[1:]), 1) + if (input.sum() + output.sum()).item() in [np.nan, np.inf]: + raise ValueError + J = torch.zeros(list(output.shape) + list(input.shape[1:])).to(input) + # they are able here to do the gradient computation one batch at a time, of course still considering only one output coordinate at a time + for i in range(output.shape[1]): + g = torch.zeros(output.shape).to(input) + g[:, i] = 1 + if diffable: + J[:, i] = torch.autograd.grad(output, input, g, only_inputs=True, retain_graph=True, create_graph=True)[0] + else: + J[:, i] = torch.autograd.grad(output, input, g, only_inputs=True, retain_graph=True)[0] + J = J.reshape(output.shape[0], output.shape[1], in_size) + return J.transpose(2, 1) + + +def jacobian_second_order(input, output, diffable=True): + ''' + Returns the Jacobian matrix (batch x in_size x out_size) of the function that produced the output evaluated at the + input, as well as + the matrix of second derivatives of outputs with respect to inputs (batch x in_size x out_size) + + Adapted from https://github.com/mwcvitkovic/MASS-Learning/blob/master/models/utils.py + + Important: need to use diffable=True in order for the training routines based on these to work! + ''' + assert len(output.shape) == 2 + assert input.shape[0] == output.shape[0] + in_size = reduce(mul, list(input.shape[1:]), 1) + if (input.sum() + output.sum()).item() in [np.nan, np.inf]: + raise ValueError + J = torch.zeros(list(output.shape) + list(input.shape[1:])).to(input) + J2 = torch.zeros(list(output.shape) + list(input.shape[1:])).to(input) + + for i in range(output.shape[1]): + g = torch.zeros(output.shape).to(input) + g[:, i] = 1 + J[:, i] = torch.autograd.grad(output, input, g, only_inputs=True, retain_graph=True, create_graph=True)[0] + J = J.reshape(output.shape[0], output.shape[1], in_size) + + for i in range(output.shape[1]): + for j in range(input.shape[1]): + g = torch.zeros(J.shape).to(input) + g[:, i, j] = 1 + if diffable: + J2[:, i, j] = torch.autograd.grad(J, input, g, only_inputs=True, retain_graph=True, create_graph=True)[ + 0][:, j] + else: + J2[:, i, j] = torch.autograd.grad(J, input, g, only_inputs=True, retain_graph=True)[0][:, j] + + J2 = J2.reshape(output.shape[0], output.shape[1], in_size) + + return J.transpose(2, 1), J2.transpose(2, 1) + + +def jacobian_hessian(input, output, diffable=True): + ''' + Returns the Jacobian matrix (batch x in_size x out_size) of the function that produced the output evaluated at the + input, as well as the Hessian matrix (batch x in_size x in_size x out_size). + + This takes slightly more than the jacobian_second_order routine. + + Adapted from https://github.com/mwcvitkovic/MASS-Learning/blob/master/models/utils.py + + Important: need to use diffable=True in order for the training routines based on these to work! + ''' + assert len(output.shape) == 2 + assert input.shape[0] == output.shape[0] + in_size = reduce(mul, list(input.shape[1:]), 1) + if (input.sum() + output.sum()).item() in [np.nan, np.inf]: + raise ValueError + J = torch.zeros(list(output.shape) + list(input.shape[1:])).to(input) + H = torch.zeros(list(output.shape) + list(input.shape[1:]) + list(input.shape[1:])).to(input) + + for i in range(output.shape[1]): + g = torch.zeros(output.shape).to(input) + g[:, i] = 1 + J[:, i] = torch.autograd.grad(output, input, g, only_inputs=True, retain_graph=True, create_graph=True)[0] + J = J.reshape(output.shape[0], output.shape[1], in_size) + + for i in range(output.shape[1]): + for j in range(input.shape[1]): + g = torch.zeros(J.shape).to(input) + g[:, i, j] = 1 + if diffable: + H[:, i, j] = torch.autograd.grad(J, input, g, only_inputs=True, retain_graph=True, create_graph=True)[0] + else: + H[:, i, j] = torch.autograd.grad(J, input, g, only_inputs=True, retain_graph=True)[0] + + return J.transpose(2, 1), H.transpose(3, 1) + + +def set_requires_grad(net, value): + for param in net.parameters(): + param.requires_grad = value diff --git a/abcpy/statistics.py b/abcpy/statistics.py index df28a03..55999c8 100644 --- a/abcpy/statistics.py +++ b/abcpy/statistics.py @@ -10,7 +10,7 @@ else: has_torch = True from abcpy.NN_utilities.utilities import load_net, save_net - from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet + from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet, DiscardLastOutputNet class Statistics(metaclass=ABCMeta): @@ -472,11 +472,17 @@ def fromFile(cls, path_to_net_state_dict, network_class=None, path_to_scaler=Non raise RuntimeError("You passed hidden_sizes as an argument, but that may be passed only if you are passing " "input_size and input_size as well, and you are not passing network_class.") - if network_class is not None: # user explicitly passed the NN class + if network_class is None: + network_class = createDefaultNN(input_size=input_size, output_size=output_size, + hidden_sizes=hidden_sizes) + + # the stored state_dict could be either a simple network or a network wrapped with DiscardLastOutput (in case + # the statistics was learned with the Exponential Family method); while instead the network class refers only to + # the actual net. Therefore need to try and load in both ways + try: net = load_net(path_to_net_state_dict, network_class) - 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)) + except RuntimeError: + net = load_net(path_to_net_state_dict, DiscardLastOutputNet, network_class()) if path_to_scaler is not None: f = open(path_to_scaler, 'rb') @@ -540,7 +546,11 @@ def statistics(self, data): data = data.cuda() # simply apply the network transformation. - data = self.net(data).cpu().detach().numpy() + try: + data = self.net(data).cpu().detach().numpy() + except (IndexError, RuntimeError, ValueError) as e: + raise RuntimeError("There was an error in passing the data through the network, likely due to the data not " + "being of the right size.") data = np.array(data) # Expand the data with polynomial expansion diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index ed567f6..39f845a 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -4,11 +4,13 @@ import matplotlib.pyplot as plt from sklearn import linear_model from sklearn.preprocessing import MinMaxScaler +from tqdm import tqdm from abcpy.acceptedparametersmanager import * from abcpy.graphtools import GraphTools # import dataset and networks definition: from abcpy.statistics import LinearTransformation +from abcpy.transformers import BoundedVarScaler # Different torch components try: @@ -17,11 +19,15 @@ has_torch = False else: has_torch = True - from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet + from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet, createDefaultNNWithDerivatives, \ + DiscardLastOutputNet from abcpy.statistics import NeuralEmbedding + from torch.optim import Adam, lr_scheduler + import torch.autograd as autograd from abcpy.NN_utilities.algorithms import FP_nn_training, triplet_training, contrastive_training -from abcpy.NN_utilities.utilities import compute_similarity_matrix +from abcpy.NN_utilities.utilities import compute_similarity_matrix, jacobian_second_order, set_requires_grad +from abcpy.NN_utilities.losses import Fisher_divergence_loss_with_c_x # TODO: there seems to be issue when n_samples_per_param >1. Check that. Should you modify the _sample_parameters-statistics function? @@ -47,7 +53,7 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_va ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -212,6 +218,48 @@ def _sample_parameter_statistics(self, rng=np.random.RandomState()): return parameter, statistics +class StatisticsLearningWithLosses(StatisticsLearning, metaclass=ABCMeta): + """This abstract base class subclasses the above and includes a utility method to plot losses. + """ + + def plot_losses(self, which_losses="both"): + """ + Plot losses vs training epochs after the NN have been trained. + + Parameters + ---------- + which_losses: string, optional + Specifies which set of losses to display (between training and test loss). + Can be "train", "test" or "both". Notice that the test loss could be unavailable (in case no test set was + used for training), in which case the test loss is not shown even if requested. Defaults to "both". + + Returns + ------- + + """ + + if which_losses not in ["both", "train", "test"]: + raise NotImplementedError("'which_losses' should be 'both', 'train' or 'test'") + + fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4)) + if which_losses in ["both", "train"]: + ax.plot(np.arange(len(self.train_losses)) + 1, self.train_losses, label="Train loss", color="C0") + if which_losses in ["both", "test"]: + if self.test_losses is not None: + if len(self.test_losses) != len(self.train_losses): + raise RuntimeError("Length of train and test losses list should be the same.") + ax.plot(np.arange(len(self.train_losses)) + 1, self.test_losses, label="Test loss", color="C1") + else: + self.logger.warning("You requested to plot test losses, but these are unavailable (probably due to no " + "test set been used during NN training.") + + ax.set_xlabel("Training epoch") + ax.set_ylabel("Loss") + ax.legend() + + return fig, ax + + class Semiautomatic(StatisticsLearning, GraphTools): """This class implements the semi automatic summary statistics learning technique described in Fearnhead and Prangle [1]. @@ -276,7 +324,7 @@ def get_statistics(self): return LinearTransformation(np.transpose(self.coefficients_learnt), previous_statistics=self.statistics_calc) -class StatisticsLearningNN(StatisticsLearning, GraphTools): +class StatisticsLearningNN(StatisticsLearningWithLosses, 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. @@ -439,6 +487,8 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l 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') + else: + raise RuntimeError("'embedding_net' needs to be either a torch.nn.Module, or a list, or None.") if cuda: self.embedding_net.cuda() @@ -477,45 +527,8 @@ def get_statistics(self): else: return NeuralEmbedding(net=self.embedding_net, previous_statistics=self.statistics_calc) - def plot_losses(self, which_losses="both"): - """ - Plot losses vs training epochs after the NN have been trained. - - Parameters - ---------- - which_losses: string, optional - Specifies which set of losses to display (between training and test loss). - Can be "train", "test" or "both". Notice that the test loss could be unavailable (in case no test set was - used for training), in which case the test loss is not shown even if requested. Defaults to "both". - - Returns - ------- - - """ - - if which_losses not in ["both", "train", "test"]: - raise NotImplementedError("'which_losses' should be 'both', 'train' or 'test'") - - fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4)) - if which_losses in ["both", "train"]: - ax.plot(np.arange(len(self.train_losses)) + 1, self.train_losses, label="Train loss", color="C0") - if which_losses in ["both", "test"]: - if self.test_losses is not None: - if len(self.test_losses) != len(self.train_losses): - raise RuntimeError("Length of train and test losses list should be the same.") - ax.plot(np.arange(len(self.train_losses)) + 1, self.test_losses, label="Test loss", color="C1") - else: - self.logger.warning("You requested to plot test losses, but these are unavailable (probably due to no " - "test set been used during NN training.") - - ax.set_xlabel("Training epoch") - ax.set_ylabel("Loss") - ax.legend() - - return fig, ax - -# the following classes subclass the base class StatisticsLearningNN with different training routines +# the following three classes subclass the base class StatisticsLearningNN with different training routines class SemiautomaticNN(StatisticsLearningNN): """This class implements the semi automatic summary statistics learning technique as described in @@ -948,3 +961,640 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample optimizer_kwargs=optimizer_kwargs, scheduler_kwargs=scheduler_kwargs, loader_kwargs=loader_kwargs) + + +class ExpFamStatistics(StatisticsLearningWithLosses, GraphTools): + def __init__(self, model, statistics_calc, backend, statistics_net=None, parameters_net=None, + embedding_dimension=None, + n_samples=1000, n_samples_val=0, parameters=None, simulations=None, + parameters_val=None, simulations_val=None, + lower_bound_simulations=None, upper_bound_simulations=None, + + sliced=True, noise_type='radermacher', variance_reduction=False, + + n_epochs=100, batch_size=16, + scale_samples=True, scale_parameters=False, + early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, + cuda=None, load_all_data_GPU=False, + + seed=None, + nonlinearity_statistics=torch.nn.Softplus, nonlinearity_parameters=torch.nn.ReLU, + batch_norm=True, batch_norm_momentum=0.1, batch_norm_update_before_test=False, + lr_simulations=1e-3, lr_parameters=1e-3, lam=0, + + optimizer_simulations=None, optimizer_parameters=None, + scheduler_simulations=None, scheduler_parameters=None, + + start_epoch_training=0, + optimizer_simulations_kwargs={}, optimizer_parameters_kwargs={}, scheduler_simulations_kwargs={}, + scheduler_parameters_kwargs={}, + use_tqdm=True): + """ + Parameters + ---------- + model: abcpy.models.Model + Model object that conforms to the Model class. + statistics_cal: abcpy.statistics.Statistics + Statistics object that conforms to the Statistics class, applied before learning the transformation. + backend: abcpy.backends.Backend + Backend object that conforms to the Backend class. + embedding_net: torch.nn object or list + it can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`), alternatively, a list + with integer numbers denoting the width of the hidden layers, from which a fully connected network with + that structure is created, having the input and output size corresponding to size of model output + (after being transformed by `statistics_calc`) and + number of parameters. In case this is None, a fully connected neural network with three hidden layers is + used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` + is the number of parameters in the model. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN` + n_samples: int, optional + 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 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 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 + 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. + use_tqdm : boolean, optional + Whether using tqdm or not to display progress. Defaults to True. + """ + self.logger = logging.getLogger(__name__) + self.scale_samples = scale_samples + self.scale_parameters = scale_parameters + self.sliced = sliced + + if lower_bound_simulations is not None and not hasattr(lower_bound_simulations, "shape"): + raise RuntimeError("Provided lower bounds need to be a numpy array.") + if upper_bound_simulations is not None and not hasattr(upper_bound_simulations, "shape"): + raise RuntimeError("Provided upper bounds need to be a numpy array.") + if upper_bound_simulations is not None and lower_bound_simulations is not None and \ + lower_bound_simulations.shape != upper_bound_simulations.shape: + raise RuntimeError("Provided lower and upper bounds need to have same shape.") + + # Define device + if not has_torch: + raise ImportError( + "Pytorch is required to instantiate an element of the {} class, in order to handle " + "neural networks. Please install it. ".format(self.__class__.__name__)) + + # set random seed for torch as well: + if seed is not None: + torch.manual_seed(seed) + + if cuda is None: + cuda = 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" + if self.device == "cuda": + self.logger.debug("We are using GPU to train the network.") + else: + self.logger.debug("We are using CPU to train the network.") + + # this handles generation of the data (or its formatting in case the data is provided to the Semiautomatic + # class) + super(ExpFamStatistics, self).__init__(model, statistics_calc, backend, n_samples, n_samples_val, + 1, 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 + self.has_val_set = hasattr(self, "sample_parameters_val") and len(self.sample_parameters_val) > 0 + + self.logger.info('Learning of the transformation...') + # Define Data + parameters, simulations = self.sample_parameters, self.sample_statistics + if self.has_val_set: + parameters_val, simulations_val = self.sample_parameters_val, self.sample_statistics_val + else: + parameters_val, simulations_val = None, None + + # define the scaler for the simulations by transforming them to a bounded domain (if needed, according to how + # the bounds are passed) and then rescaling to the [0,1] interval. + if lower_bound_simulations is None and upper_bound_simulations is None and not scale_samples: + # in this case we do not use any scaler for the simulations + self.has_scaler_for_simulations = False + else: + self.has_scaler_for_simulations = True + + if lower_bound_simulations is None: + lower_bound_simulations = np.array([None] * simulations.shape[1]) + if upper_bound_simulations is None: + upper_bound_simulations = np.array([None] * simulations.shape[1]) + self.scaler_simulations = BoundedVarScaler(lower_bound_simulations, upper_bound_simulations, + rescale_transformed_vars=self.scale_samples).fit(simulations) + simulations = self.scaler_simulations.transform(simulations) + if self.has_val_set: + simulations_val = self.scaler_simulations.transform(simulations_val) + + # now scale the parameters + if self.scale_parameters: + self.scaler_parameters = MinMaxScaler().fit(parameters) + parameters = self.scaler_parameters.transform(parameters) + if self.has_val_set: + parameters_val = self.scaler_parameters.transform(parameters_val) + + # torch.tensor(scaler.transform(samples.reshape(-1, samples.shape[-1])).astype("float32"), + # requires_grad=requires_grad).reshape(samples.shape) + + # transform to torch tensors: + simulations = torch.tensor(simulations.astype("float32"), requires_grad=True) + parameters = torch.tensor(parameters.astype("float32"), requires_grad=False) + if self.has_val_set: + simulations_val = torch.tensor(simulations_val.astype("float32"), requires_grad=True) + parameters_val = torch.tensor(parameters_val.astype("float32"), requires_grad=False) + + # now setup the default neural network or not + + if embedding_dimension is None: + embedding_dimension = parameters.shape[1] + + if isinstance(statistics_net, torch.nn.Module): + self.statistics_net = statistics_net + self.logger.debug('We use the provided neural network for the summary statistics') + + elif isinstance(statistics_net, list) or statistics_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.statistics_net = createDefaultNNWithDerivatives(input_size=simulations.shape[1], + output_size=embedding_dimension + 1, + hidden_sizes=statistics_net, + nonlinearity=nonlinearity_statistics)() + self.logger.debug('We generate a default neural network for the summary statistics') + else: + raise RuntimeError("'statistics_net' needs to be either a torch.nn.Module, or a list, or None.") + + if isinstance(parameters_net, torch.nn.Module): + self.parameters_net = parameters_net + self.logger.debug('We use the provided neural network for the parameters') + + elif isinstance(parameters_net, list) or parameters_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.parameters_net = createDefaultNN(input_size=parameters.shape[1], output_size=embedding_dimension, + hidden_sizes=parameters_net, nonlinearity=nonlinearity_parameters(), + batch_norm_last_layer=batch_norm, + batch_norm_last_layer_momentum=batch_norm_momentum)() + self.logger.debug('We generate a default neural network for the parameters') + else: + raise RuntimeError("'parameters_net' needs to be either a torch.nn.Module, or a list, or None.") + + if cuda: + self.statistics_net.cuda() + self.parameters_net.cuda() + + self.logger.debug('We now run the training routine') + self.train_losses, self.test_losses = self._train(simulations, parameters, simulations_val, parameters_val, + n_epochs=n_epochs, use_tqdm=use_tqdm, + early_stopping=early_stopping, + load_all_data_GPU=load_all_data_GPU, + lr_simulations=lr_simulations, lr_parameters=lr_parameters, + batch_size=batch_size, + epochs_test_interval=epochs_early_stopping_interval, + epochs_before_early_stopping=start_epoch_early_stopping, + batch_norm_update_before_test=batch_norm_update_before_test, + noise_type=noise_type, variance_reduction=variance_reduction, + optimizer_simulations=optimizer_simulations, + optimizer_parameters=optimizer_parameters, + scheduler_simulations=scheduler_simulations, + scheduler_parameters=scheduler_parameters, + + optimizer_simulations_kwargs=optimizer_simulations_kwargs, + optimizer_parameters_kwargs=optimizer_parameters_kwargs, + scheduler_simulations_kwargs=scheduler_simulations_kwargs, + scheduler_parameters_kwargs=scheduler_parameters_kwargs, + + lam=lam, start_epoch_training=start_epoch_training, + ) + self.logger.info("Finished learning the transformation.") + + # move back the nets to CPU. + self.statistics_net.cpu() + self.parameters_net.cpu() + + # todo better names overall. + + def get_statistics(self, rescale_statistics=True): + """ + 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. + + Parameters + ---------- + rescale_statistics : boolean, optional + If this is set to True (default), then the returned statistics will be standardized, such that the + different components of the statistics have the same scale. The standardization works by dividing each + statistic by the standard deviation achieved on a reference set of simulations. Here, the used set is + either the validation set used in training (if available) or the training set. If False, no + standardization is used. Defaults to True. + + Returns + ------- + abcpy.statistics.NeuralEmbedding object + a statistics object that implements the learned transformation. + """ + if self.has_scaler_for_simulations: + net = ScalerAndNet(net=DiscardLastOutputNet(self.statistics_net), scaler=self.scaler_simulations) + else: + net = DiscardLastOutputNet(self.statistics_net) + + if rescale_statistics: + # We need a hacky way here. In fact sample_statistics is the one you obtain after the first + # statistics_calc is applied; if you initialize Neural embedding with the statistics_calc directly, + # that is applied again, which is not correct. + # Then we first instantiate the NeuralEmbedding without statistics_calc, and then add it later. In this way + # the standard deviation is computed correctly, but the behavior of the Statistics in new data will also be + # correct. + statistics_calc_new = NeuralEmbedding(net=net, + reference_simulations=self.sample_statistics_val if self.has_val_set else self.sample_statistics) + statistics_calc_new.previous_statistics = self.statistics_calc + else: + statistics_calc_new = NeuralEmbedding(net=net, previous_statistics=self.statistics_calc) + return statistics_calc_new + + def get_simulations_network(self): + """ + todo fix docstring + 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 ScalerAndNet(self.statistics_net, + self.scaler_simulations) if self.has_scaler_for_simulations else self.statistics_net + + def get_parameters_network(self): + """ + todo fix docstring + 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 ScalerAndNet(self.parameters_net, self.scaler_parameters) if self.scale_parameters else \ + self.parameters_net + + def get_simulations_scaler(self): + """ + todo fix docstring + 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 self.scaler_simulations if self.has_scaler_for_simulations else None + + def get_parameters_scaler(self): + """ + todo fix docstring + 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 self.scaler_parameters if self.scale_parameters else None + + def _train(self, samples_matrix, theta_vect, + samples_matrix_test=None, theta_vect_test=None, epochs_test_interval=10, + epochs_before_early_stopping=100, + early_stopping=False, + n_epochs=100, batch_size=None, lr_simulations=0.001, lr_parameters=0.001, + load_all_data_GPU=False, + batch_norm_update_before_test=False, + noise_type='radermacher', variance_reduction=False, + optimizer_simulations=None, optimizer_parameters=None, + scheduler_simulations=None, scheduler_parameters=None, + optimizer_simulations_kwargs={}, optimizer_parameters_kwargs={}, + scheduler_simulations_kwargs={}, scheduler_parameters_kwargs={}, + start_epoch_training=0, + lam=0, use_tqdm=False): + """This assumes samples matrix to be a 2d tensor with size (n_theta, size_sample) and theta_vect a 2d tensor with + size (n_theta, p). + """ + if self.sliced: + batch_steps = lambda samples, etas: self.single_sliced_score_matching(samples, etas, noise_type=noise_type, + variance_reduction=variance_reduction) + else: + batch_steps = lambda samples, etas: self._batch_Fisher_div_with_c_x(samples, etas, lam=lam) + + if load_all_data_GPU: + # we move all data to the gpu; it needs to be small enough + samples_matrix = samples_matrix.to(self.device) + if samples_matrix_test is not None: + samples_matrix_test = samples_matrix_test.to(self.device) + theta_vect = theta_vect.to(self.device) + if theta_vect_test is not None: + theta_vect_test = theta_vect_test.to(self.device) + + compute_test_loss = False + if theta_vect_test is not None and samples_matrix_test is not None: + test_loss_list = [] + compute_test_loss = True + n_theta_test = theta_vect_test.shape[0] + + if optimizer_simulations is None: + optimizer_simulations = Adam(self.statistics_net.parameters(), lr=lr_simulations, + **optimizer_simulations_kwargs) + else: + optimizer_simulations = optimizer_simulations(self.statistics_net.parameters(), lr=lr_simulations, + **optimizer_simulations_kwargs) + + if optimizer_parameters is None: + optimizer_parameters = Adam(self.parameters_net.parameters(), lr=lr_parameters, + **optimizer_parameters_kwargs) + else: + optimizer_parameters = optimizer_parameters(self.parameters_net.parameters(), lr=lr_parameters, + **optimizer_parameters_kwargs) + + if batch_size is None: # in this case use full batch + batch_size = theta_vect.shape[0] + + n_theta = theta_vect.shape[0] + + loss_list = [] + + # define now the LR schedulers: + enable_scheduler_simulations = True + enable_scheduler_parameters = True + + if scheduler_simulations is False: + enable_scheduler_simulations = False + else: + if scheduler_simulations is None: + # default scheduler + scheduler_simulations = lr_scheduler.ExponentialLR + if len(scheduler_simulations_kwargs) == 0: # no arguments provided + scheduler_simulations_kwargs = dict(gamma=0.99) + + # instantiate the scheduler + scheduler_simulations = scheduler_simulations(optimizer_simulations, **scheduler_simulations_kwargs) + + if scheduler_parameters is False: + enable_scheduler_parameters = False + else: + if scheduler_parameters is None: + # default scheduler + scheduler_parameters = lr_scheduler.ExponentialLR + if len(scheduler_parameters_kwargs) == 0: # no arguments provided + scheduler_parameters_kwargs = dict(gamma=0.99) + + # instantiate the scheduler + scheduler_parameters = scheduler_parameters(optimizer_parameters, **scheduler_parameters_kwargs) + + # initialize the state_dict variables: + net_state_dict = None + net_state_dict_theta = None + + for epoch in range(0, start_epoch_training): + if enable_scheduler_simulations: + scheduler_simulations.step() + if enable_scheduler_parameters: + scheduler_parameters.step() + + for epoch in tqdm(range(start_epoch_training, n_epochs), disable=not use_tqdm): + # print("epoch", epoch) + # set nets to train mode (needed as there may be a batchnorm layer there): + self.statistics_net.train() + self.parameters_net.train() + + indeces = self.rng.permutation(n_theta) # this may be a bottleneck computationally? + batch_index = 0 + total_train_loss_epoch = 0 + + # loop over batches + while batch_size * batch_index < n_theta: + # print(batch_index) + optimizer_simulations.zero_grad() + optimizer_parameters.zero_grad() + + # by writing in this way, if we go above the number of elements in the vector, you don't care + batch_indeces = indeces[batch_size * batch_index:batch_size * (batch_index + 1)] + + thetas_batch = theta_vect[batch_indeces].to(self.device) + + # compute the transformed parameter values for the batch: + etas = self.parameters_net(thetas_batch) + + samples_batch = samples_matrix[batch_indeces].to(self.device) + # now call the batch routine that takes care of forward step of simulations as well + batch_loss = batch_steps(samples_batch, etas) + + total_train_loss_epoch += batch_loss.item() + + # set requires_grad to False to save computation + if lr_simulations == 0: + set_requires_grad(self.statistics_net, False) + if lr_parameters == 0: + set_requires_grad(self.parameters_net, False) + + batch_loss.backward() + + # reset it + if lr_simulations == 0: + set_requires_grad(self.statistics_net, True) + if lr_parameters == 0: + set_requires_grad(self.parameters_net, True) + + optimizer_simulations.step() + optimizer_parameters.step() + + batch_index += 1 + + loss_list.append(total_train_loss_epoch / (batch_index + 1)) + + # at each epoch we compute the test loss; we need to use batches as well here, otherwise it may not fit + # to GPU memory + if compute_test_loss: + # first, we do forward pass of all the training data in order to update the batchnorm running means + # (if a batch norm layer is there): + if batch_norm_update_before_test: + with torch.no_grad(): + batch_index = 0 + while batch_size * batch_index < n_theta: + # the batchnorm is usually after the net; then, it is enough to feedforward the data there: + thetas_batch = theta_vect[batch_size * batch_index:batch_size * (batch_index + 1)].to( + self.device) + _ = self.parameters_net(thetas_batch) + batch_index += 1 + + self.statistics_net.eval() + self.parameters_net.eval() + + batch_index = 0 + total_test_loss_epoch = 0 + while batch_size * batch_index < n_theta_test: + # no need to shuffle the test data: + thetas_batch = theta_vect_test[batch_size * batch_index:batch_size * (batch_index + 1)].to( + self.device) + samples_batch = samples_matrix_test[batch_size * batch_index:batch_size * (batch_index + 1)].to( + self.device) + + # compute the transformed parameter values for the batch: + etas_test = self.parameters_net(thetas_batch) + + total_test_loss_epoch += batch_steps(samples_batch, etas_test).item() + + batch_index += 1 + + test_loss_list.append(total_test_loss_epoch / (batch_index + 1)) + + # the test loss on last step is larger than the training_dataset_index before, stop training + if early_stopping and (epoch + 1) % epochs_test_interval == 0: + # after `epochs_before_early_stopping` epochs, we can stop only if we saved a state_dict before + # (ie if at least epochs_test_interval epochs have passed). + if epoch + 1 > epochs_before_early_stopping and net_state_dict is not None: + if test_loss_list[-1] > test_loss_list[- 1 - epochs_test_interval]: + self.logger.info("Training has been early stopped at epoch {}.".format(epoch + 1)) + # reload the previous state dict: + self.statistics_net.load_state_dict(net_state_dict) + self.parameters_net.load_state_dict(net_state_dict_theta) + break # stop training + # if we did not stop: update the state dict + net_state_dict = self.statistics_net.state_dict() + net_state_dict_theta = self.parameters_net.state_dict() + + if enable_scheduler_simulations: + scheduler_simulations.step() + if enable_scheduler_parameters: + scheduler_parameters.step() + + # after training, return to eval mode: + self.statistics_net.eval() + self.parameters_net.eval() + + if compute_test_loss: + return loss_list, test_loss_list + else: + return loss_list, None + + def _batch_Fisher_div_with_c_x(self, samples, etas, lam=0): + # do the forward pass at once here: + if hasattr(self.statistics_net, "forward_and_derivatives"): + transformed_samples, f, s = self.statistics_net.forward_and_derivatives(samples) + else: + transformed_samples = self.statistics_net(samples) + f, s = jacobian_second_order(samples, transformed_samples, diffable=True) + + f = f.reshape(-1, f.shape[1], f.shape[2]) + s = s.reshape(-1, s.shape[1], s.shape[2]) + + return Fisher_divergence_loss_with_c_x(f, s, etas, lam=lam) / (samples.shape[0]) + + def single_sliced_score_matching(self, samples, etas, noise=None, detach=False, noise_type='radermacher', + variance_reduction=False): + """Can either receive noise as an input or generate it. etas have been (optionally) pre-transformed by + statistics net""" + # -- THE FOLLOWING MODIFIED FROM: https://github.com/ermongroup/sliced_score_matching/blob/master/losses/sliced_sm.py -- + # these take care of generating the projection samples and computing the loss by taking the grad. + + # single_sliced_score_matching and sliced_VR_score_matching implement a basic version of SSM + # with only M=1. These are used in density estimation experiments for DKEF. + reshaped_etas = etas.view(-1, etas.shape[-1]) # THIS IS USELESS! + reshaped_etas = torch.cat((reshaped_etas, torch.ones(reshaped_etas.shape[0], 1).to(reshaped_etas)), + dim=1) # append a 1 + reshaped_samples = samples.view(-1, samples.shape[-1]) + reshaped_samples.requires_grad_(True) + + if noise is None: + vectors = torch.randn_like(reshaped_samples).to(reshaped_samples) + if noise_type == 'radermacher': + vectors = vectors.sign() + elif noise_type == 'sphere': + if variance_reduction: + raise RuntimeError("Noise of type 'sphere' can't be used with variance reduction.") + else: + vectors = vectors / torch.norm(vectors, dim=-1, keepdim=True) * np.sqrt(vectors.shape[-1]) + elif noise_type == 'gaussian': + pass + else: + raise RuntimeError("Noise type not implemented") + else: + vectors = noise + + transformed_samples = self.statistics_net(reshaped_samples) + logp = torch.bmm(reshaped_etas.unsqueeze(1), transformed_samples.unsqueeze(2)) # way to do batch dot products + logp = logp.sum() + grad1 = autograd.grad(logp, reshaped_samples, create_graph=True)[0] + gradv = torch.sum(grad1 * vectors) + if variance_reduction: + loss1 = torch.norm(grad1, dim=-1) ** 2 * 0.5 # this is the only difference + else: + loss1 = torch.sum(grad1 * vectors, dim=-1) ** 2 * 0.5 + if detach: + loss1 = loss1.detach() + grad2 = autograd.grad(gradv, reshaped_samples, create_graph=True)[0] + loss2 = torch.sum(vectors * grad2, dim=-1) + if detach: + loss2 = loss2.detach() + + loss = (loss1 + loss2).mean() + return loss diff --git a/abcpy/transformers.py b/abcpy/transformers.py index e344a9b..9a62d01 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -1,17 +1,36 @@ +import torch import numpy as np +from sklearn.preprocessing import MinMaxScaler -# these transformers are used in the MCMC inference scheme, in order to run MCMC of an unbounded transformed space in -# case the original space is bounded. It therefore also implements the jacobian terms which appear in the acceptance -# rate. +# The first two transformers are used in the MCMC inference scheme, in order to run MCMC of an unbounded transformed +# space in case the original space is bounded. It therefore also implements the jacobian terms which appear in +# the acceptance rate. BoundedVarScaler is instead used in the training routine for the Exponential Family summary +# statistics learning. class BoundedVarTransformer: """ - This scaler implements both lower bounded and two sided bounded transformations according to the provided bounds; + This scaler implements both lower bounded and two sided bounded transformations according to the provided bounds. + It works on 1d vectors. You need to specify separately the lower and upper bounds in two arrays with the same length + of the objects on which the transformations will be applied (likely the parameters on which MCMC is conducted for + this function). + + If the bounds for a given variable are both None, it is assumed to be unbounded; if instead the + lower bound is given and the upper bound is None, it is assumed to be lower bounded. Finally, if both bounds are + given, it is assumed to be bounded on both sides. """ def __init__(self, lower_bound, upper_bound): - + """ + Parameters + ---------- + lower_bound : np.ndarray + Array of the same length of the variable to which the transformation will be applied, containing lower + bounds of the variable. Each entry of the array can be either None or a number (see above). + upper_bound + Array of the same length of the variable to which the transformation will be applied, containing upper + bounds of the variable. Each entry of the array can be either None or a number (see above). + """ # upper and lower bounds need to be numpy arrays with size the size of the variable self.lower_bound = lower_bound self.upper_bound = upper_bound @@ -172,7 +191,7 @@ def jac_log_det(self, x): Parameters ---------- x : list of len n_parameters - Input data, living in the original space (with bounds). + Input data, living in the original space (with optional bounds). Returns ------- res : float @@ -185,7 +204,7 @@ def jac_log_det(self, x): def jac_log_det_inverse_transform(self, x): """Returns the log determinant of the Jacobian evaluated in the inverse transform: - :math:`\log |J_t(t^{-1}(x))| = - log |J_{t^{-1}}(x)|` + :math:`\log |J_t(t^{-1}(x))| = - \log |J_{t^{-1}}(x)|` Parameters ---------- @@ -218,3 +237,183 @@ def jac_log_det(self, x): def jac_log_det_inverse_transform(self, x): return 0 + + +class BoundedVarScaler(MinMaxScaler, BoundedVarTransformer): + """ + This scaler implements both lower bounded and two sided bounded transformations according to the provided bounds. + After the nonlinear transformation is applied, we optionally rescale the transformed variables to the (0,1) + range (default for this is True). + + It works on 2d vectors. You need to specify separately the lower and upper bounds in two arrays with the same length + of the objects on which the transformations will be applied (likely the simulations used to learn the + exponential family summaries for this one). + + If the bounds for a given variable are both None, it is assumed to be unbounded; if instead the + lower bound is given and the upper bound is None, it is assumed to be lower bounded. Finally, if both bounds are + given, it is assumed to be bounded on both sides. + + Practically, this inherits from BoundedVarTransformer, which provides the transformations, and from sklearn + MinMaxScaler, which provides the rescaling capabilities. This class has the same API as sklearn scalers, + implementing fit and transform methods. + """ + + def __init__(self, lower_bound, upper_bound, feature_range=(0, 1), copy=True, rescale_transformed_vars=True): + """ + Parameters + ---------- + lower_bound : np.ndarray + Array of the same length of the variable to which the transformation will be applied, containing lower + bounds of the variable. Each entry of the array can be either None or a number (see above). + upper_bound + Array of the same length of the variable to which the transformation will be applied, containing upper + bounds of the variable. Each entry of the array can be either None or a number (see above). + feature_range : tuple (min, max), optional + Desired range of transformed data (obtained with the MinMaxScaler after the + nonlinear transformation is computed). Default=(0, 1) + copy : bool, optional + Set to False to perform inplace row normalization and avoid a + copy in the MinMaxScaler (if the input is already a numpy array). Defaults to True. + rescale_transformed_vars : bool, optional + Whether to apply the MinMaxScaler after the nonlinear transformation. Defaults to True. + """ + BoundedVarTransformer.__init__(self, lower_bound, upper_bound) + + MinMaxScaler.__init__(self, feature_range=feature_range, copy=copy) + self.rescale_transformed_vars = rescale_transformed_vars + + @staticmethod + def _check_reshape_single_sample(x): + if len(x.shape) == 1: + pass + elif len(x.shape) == 2 and x.shape[0] == 1: + x = x.reshape(-1) + else: + raise RuntimeError("This can be computed for one sample at a time.") + return x + + def fit(self, X, y=None): + """Compute the minimum and maximum to be used for later scaling. + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + The data used to compute the per-feature minimum and maximum + used for later scaling along the features axis. + y : None + Ignored. + Returns + ------- + self : object + Fitted scaler. + """ + # need to check if we can apply the log first: + if isinstance(X, torch.Tensor): + X = X.detach().numpy() + self._check_data_in_bounds(X) + + # we first transform the data with the log transformation and then apply the scaler (optionally): + X = self._apply_nonlinear_transf(X) + + if self.rescale_transformed_vars: + return MinMaxScaler.fit(self, X) + else: + return self + + def transform(self, X): + """Scale features of X according to feature_range. + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + Input data that will be transformed. + Returns + ------- + Xt : array-like of shape (n_samples, n_features) + Transformed data. + """ + # need to check if we can apply the log first: + if isinstance(X, torch.Tensor): + X = X.detach().numpy() + self._check_data_in_bounds(X) + + # we first transform the data with the log transformation and then apply the scaler (optionally): + X = self._apply_nonlinear_transf(X) + + if self.rescale_transformed_vars: + return MinMaxScaler.transform(self, X) + else: + return X + + def inverse_transform(self, X): + """Undo the scaling of X according to feature_range. + Parameters + ---------- + X : array-like of shape (n_samples, n_features) + Input data that will be transformed. It cannot be sparse. + Returns + ------- + Xt : array-like of shape (n_samples, n_features) + Transformed data. + """ + if self.rescale_transformed_vars: + X = MinMaxScaler.inverse_transform(self, X) + + # now apply the inverse transform + inv_X = BoundedVarTransformer._apply_inverse_nonlinear_transf(self, X) + + return inv_X + + def jac_log_det(self, x): + """Returns the log determinant of the Jacobian: :math:`\log |J_t(x)|`. + + Note that this considers only the Jacobian arising from the non-linear transformation, neglecting the scaling + term arising from the subsequent linear rescaling. In fact, the latter does not play any role in MCMC acceptance + rate. + + Parameters + ---------- + x : array-like of shape (n_features) + Input data, living in the original space (with optional bounds). + Returns + ------- + res : float + log determinant of the jacobian + """ + if isinstance(x, torch.Tensor): + x = x.detach().numpy() + x = self._check_reshape_single_sample(x) + self._check_data_in_bounds(x.reshape(1, -1)) + + return BoundedVarTransformer._jac_log_det(self, x) + + def jac_log_det_inverse_transform(self, x): + """Returns the log determinant of the Jacobian evaluated in the inverse transform: + :math:`\log |J_t(t^{-1}(x))| = - \log |J_{t^{-1}}(x)|` + + Note that this considers only the Jacobian arising from the non-linear transformation, neglecting the scaling + term arising from the subsequent linear rescaling. In fact, the latter does not play any role in MCMC acceptance + rate. + + Parameters + ---------- + x : array-like of shape (n_features) + Input data, living in the transformed space (spanning the whole :math:`R^d`). It needs to be the value + obtained after the optional linear rescaling is applied. + Returns + ------- + res : float + log determinant of the jacobian evaluated in :math:`t^{-1}(x)` + """ + if isinstance(x, torch.Tensor): + x = x.detach().numpy() + + if self.rescale_transformed_vars: + # you still need to apply the inverse linear transformation in the transformed space to compute the jacobian + # for the right value of t^-1(x) (even if the jacobian itself does not take into account the linear + # transformation). Otherwise this function does computes the jacobian in the point obtained by applying the + # nonlinear inverse transformation to the input x, which is not correct if x was rescaled in the (0,1) + # range + x = MinMaxScaler.inverse_transform(self, np.atleast_2d(x)) + + x = self._check_reshape_single_sample(x) + + return BoundedVarTransformer._jac_log_det_inverse_transform(self, x) diff --git a/tests/NN_utilities_networks_tests.py b/tests/NN_utilities_networks_tests.py new file mode 100644 index 0000000..11cae29 --- /dev/null +++ b/tests/NN_utilities_networks_tests.py @@ -0,0 +1,75 @@ +import unittest + +try: + import torch +except ImportError: + has_torch = False +else: + has_torch = True + from abcpy.NN_utilities.networks import createDefaultNNWithDerivatives, createDefaultNN, DiscardLastOutputNet + from abcpy.NN_utilities.utilities import jacobian_second_order, jacobian, jacobian_hessian + + +class test_default_NN_with_derivatives(unittest.TestCase): + + def setUp(self): + self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus)() + self.net_first_der_only = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus, + first_derivative_only=True)() + self.tensor = torch.randn((10, 5), requires_grad=True) + + def test_first_der(self): + # compute derivative with forward pass + y, f1 = self.net_first_der_only.forward_and_derivatives(self.tensor) + f2 = jacobian(self.tensor, y) + + assert torch.allclose(f1, f2) + + def test_first_and_second_der(self): + # compute derivative with forward pass + y, f1, s1 = self.net.forward_and_derivatives(self.tensor) + f2, s2 = jacobian_second_order(self.tensor, y) + + assert torch.allclose(f1, f2) + assert torch.allclose(s1, s2) + + def test_first_der_and_hessian(self): + # compute derivative with forward pass + y, f1, H1 = self.net.forward_and_full_derivatives(self.tensor) + f2, H2 = jacobian_hessian(self.tensor, y) + + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) + + def test_error(self): + with self.assertRaises(RuntimeError): + self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softsign)() + + +class test_discard_last_output_wrapper(unittest.TestCase): + + def setUp(self): + self.net = createDefaultNN(2, 3)() + self.net_with_discard_wrapper = DiscardLastOutputNet(self.net) + # reference input and output + torch.random.manual_seed(1) + self.tensor_1 = torch.randn(2) + self.tensor_2 = torch.randn(1, 2) + self.tensor_3 = torch.randn(1, 3, 2) + + def test_output(self): + out = self.net(self.tensor_1) + out_discard = self.net_with_discard_wrapper(self.tensor_1) + self.assertTrue(torch.allclose(out[:-1], out_discard)) + + out = self.net(self.tensor_2) + out_discard = self.net_with_discard_wrapper(self.tensor_2) + self.assertTrue(torch.allclose(out[:, :-1], out_discard)) + + out = self.net(self.tensor_3) + out_discard = self.net_with_discard_wrapper(self.tensor_3) + self.assertTrue(torch.allclose(out[:, :, :-1], out_discard)) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/NN_utilities_utilities_tests.py b/tests/NN_utilities_utilities_tests.py new file mode 100644 index 0000000..862b388 --- /dev/null +++ b/tests/NN_utilities_utilities_tests.py @@ -0,0 +1,92 @@ +import unittest + +import numpy as np + +from abcpy.statistics import Identity, LinearTransformation, NeuralEmbedding + +try: + import torch +except ImportError: + has_torch = False +else: + has_torch = True + from abcpy.NN_utilities.utilities import jacobian_second_order, jacobian, jacobian_hessian + from abcpy.NN_utilities.networks import createDefaultNN + + +class test_jacobian_functions(unittest.TestCase): + # it tests that this gives the correct errors and that the result is same if you put diffable=True or False. + # it does not test that the derivatives numerical errors are correct but they are. + + def setUp(self): + net = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=False)() + net_bn = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=True)() + self.tensor = torch.randn((10, 5), requires_grad=True) + self.y = net(self.tensor) + self.y_bn = net_bn(self.tensor) + + self.y_with_infinities = self.y.detach().clone() + self.y_with_infinities[0, 0] = np.inf + + self.f, self.s = jacobian_second_order(self.tensor, self.y) # reference derivatives + self.f_bn, self.s_bn = jacobian_second_order(self.tensor, self.y_bn) # reference derivatives + + def test_first_der(self): + # compute derivative with forward pass + f2 = jacobian(self.tensor, self.y, diffable=False) + + assert torch.allclose(self.f, f2) + + def test_first_and_second_der(self): + # compute derivative with forward pass + f2, s2 = jacobian_second_order(self.tensor, self.y, diffable=False) + + assert torch.allclose(self.f, f2) + assert torch.allclose(self.s, s2) + + def test_first_der_and_hessian(self): + # compute derivative with forward pass + f1, H1 = jacobian_hessian(self.tensor, self.y) + f2, H2 = jacobian_hessian(self.tensor, self.y, diffable=False) + s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix + + assert torch.allclose(self.f, f2) + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) + assert torch.allclose(self.s, s2) + + def test_first_der_bn(self): + # compute derivative with forward pass + f2 = jacobian(self.tensor, self.y_bn, diffable=False) + + assert torch.allclose(self.f_bn, f2) + + def test_first_and_second_der_bn(self): + # compute derivative with forward pass + f2, s2 = jacobian_second_order(self.tensor, self.y_bn, diffable=False) + + assert torch.allclose(self.f_bn, f2) + assert torch.allclose(self.s_bn, s2) + + def test_first_der_and_hessian_bn(self): + # compute derivative with forward pass + f1, H1 = jacobian_hessian(self.tensor, self.y_bn) + f2, H2 = jacobian_hessian(self.tensor, self.y_bn, diffable=False) + s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix + + assert torch.allclose(self.f_bn, f2) + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) + assert torch.allclose(self.s_bn, s2) + + def test_errors(self): + with self.assertRaises(ValueError): + f1 = jacobian(self.tensor, self.y_with_infinities) + with self.assertRaises(ValueError): + f1, s1 = jacobian_second_order(self.tensor, self.y_with_infinities) + with self.assertRaises(ValueError): + f1, H1 = jacobian_hessian(self.tensor, self.y_with_infinities) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/statistics_tests.py b/tests/statistics_tests.py index 996aa49..0e008d1 100644 --- a/tests/statistics_tests.py +++ b/tests/statistics_tests.py @@ -13,7 +13,7 @@ has_torch = False else: has_torch = True - from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet + from abcpy.NN_utilities.networks import createDefaultNN, ScalerAndNet, DiscardLastOutputNet class IdentityTests(unittest.TestCase): @@ -127,12 +127,15 @@ def setUp(self): if has_torch: self.net = createDefaultNN(2, 3)() self.net_with_scaler = ScalerAndNet(self.net, None) + self.net_with_discard_wrapper = DiscardLastOutputNet(self.net) self.stat_calc = NeuralEmbedding(self.net) self.stat_calc_with_scaler = NeuralEmbedding(self.net_with_scaler) + self.stat_calc_with_discard_wrapper = NeuralEmbedding(self.net_with_discard_wrapper) # reference input and output torch.random.manual_seed(1) self.tensor = torch.randn(1, 2) self.out = self.net(self.tensor) + self.out_discard = self.net_with_discard_wrapper(self.tensor) # try now the statistics rescaling option: mu = Uniform([[-5.0], [5.0]], name='mu') @@ -166,18 +169,34 @@ 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") + stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", input_size=2, output_size=3) + stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3)) + stat_calc_loaded_with_scaler = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3), + path_to_scaler="scaler.pkl") + # test the network was recovered correctly + out_new = stat_calc_loaded.net(self.tensor) + self.assertTrue(torch.allclose(self.out, out_new)) + + # now with the DiscardLastOutput wrapper + self.stat_calc_with_discard_wrapper.save_net("net_with_discard_wrapper.pth") + stat_calc_with_discard_loaded = NeuralEmbedding.fromFile("net_with_discard_wrapper.pth", input_size=2, + output_size=3) + # test the network was recovered correctly + out_new_discard = stat_calc_with_discard_loaded.net(self.tensor) + self.assertTrue(torch.allclose(self.out_discard, out_new_discard)) + + # now with both DiscardLastOutput and Scaler wrappers + stat_calc_with_discard_and_scaler_loaded = NeuralEmbedding.fromFile("net_with_discard_wrapper.pth", + input_size=2, output_size=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]) + stat_calc_loaded = NeuralEmbedding.fromFile("net.pth") + stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3), + input_size=1) + stat_calc_loaded = NeuralEmbedding.fromFile("net.pth", network_class=createDefaultNN(2, 3), + hidden_sizes=[2, 3]) if __name__ == '__main__': diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py index 072c2c3..39aadb0 100644 --- a/tests/statisticslearning_tests.py +++ b/tests/statisticslearning_tests.py @@ -7,7 +7,7 @@ from abcpy.continuousmodels import Uniform from abcpy.statistics import Identity from abcpy.statisticslearning import Semiautomatic, SemiautomaticNN, TripletDistanceLearning, \ - ContrastiveDistanceLearning + ContrastiveDistanceLearning, ExpFamStatistics try: import torch @@ -15,6 +15,7 @@ has_torch = False else: has_torch = True + from abcpy.NN_utilities.networks import createDefaultNN class SemiautomaticTests(unittest.TestCase): @@ -65,7 +66,7 @@ def setUp(self): if has_torch: # Initialize statistics learning self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100, - n_samples_val=100, n_samples_per_param=1, seed=1, n_epochs=10, + n_samples_val=100, n_samples_per_param=1, seed=1, n_epochs=2, scale_samples=False, use_tqdm=False) self.statisticslearning2 = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=10, n_samples_val=10, n_samples_per_param=1, seed=1, n_epochs=5, @@ -73,7 +74,7 @@ def setUp(self): # 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, use_tqdm=False) + n_epochs=2, scale_samples=True, use_tqdm=False) def test_initialization(self): if not has_torch: @@ -96,13 +97,17 @@ def test_transformation(self): 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])]) + self.assertRaises(RuntimeError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) def test_errors(self): if has_torch: 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, + embedding_net=createDefaultNN(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))) @@ -179,13 +184,13 @@ def setUp(self): # Initialize statistics learning self.statisticslearning = ContrastiveDistanceLearning([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_val=100, - n_samples_per_param=1, seed=1, n_epochs=10, + n_samples_per_param=1, seed=1, n_epochs=2, scale_samples=False, use_tqdm=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, + n_epochs=2, scale_samples=True, use_tqdm=False) def test_initialization(self): @@ -210,7 +215,7 @@ def test_transformation(self): 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])]) + self.assertRaises(RuntimeError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) def test_plots(self): if has_torch: @@ -236,12 +241,12 @@ def setUp(self): # Initialize statistics learning self.statisticslearning = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_val=100, n_samples_per_param=1, - seed=1, n_epochs=10, scale_samples=False, use_tqdm=False) + seed=1, n_epochs=2, scale_samples=False, use_tqdm=False) # with sample scaler: self.statisticslearning_with_scaler = TripletDistanceLearning([self.Y], self.statistics_cal, self.backend, scale_samples=True, use_tqdm=False, n_samples=100, n_samples_per_param=1, seed=1, - n_epochs=10) + n_epochs=2) def test_initialization(self): if not has_torch: @@ -264,7 +269,7 @@ def test_transformation(self): 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])]) + self.assertRaises(RuntimeError, self.new_statistics_calculator_with_scaler.statistics, [np.array([1, 2])]) def test_plots(self): if has_torch: @@ -273,5 +278,175 @@ def test_plots(self): self.statisticslearning.plot_losses(which_losses="test") +class ExpFamStatisticsTests(unittest.TestCase): + def setUp(self): + # define prior and model + sigma = Uniform([[1], [2]]) + mu = Normal([0, 1]) + self.Y = Normal([mu, sigma]) + + # define backend + self.backend = Backend() + + # define statistics + self.statistics_cal = Identity(degree=3, cross=False) + + if has_torch: + self.statisticslearning_all_defaults = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False) + self.statisticslearning_no_sliced = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + sliced=False, use_tqdm=False) + self.statisticslearning_sphere_noise = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + noise_type="sphere") + self.statisticslearning_gaussian_noise = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + noise_type="gaussian") + self.statisticslearning_variance_reduction = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + variance_reduction=True) + self.statisticslearning_no_bn = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=4, + n_epochs=2, batch_norm=False, use_tqdm=False) + self.statisticslearning_provide_nets = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + statistics_net=createDefaultNN(3, 3)(), + parameters_net=createDefaultNN(2, 2)(), + use_tqdm=False) + self.statisticslearning_embedding_dim = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + embedding_dimension=4, use_tqdm=False) + self.statisticslearning_validation_early_stop = ExpFamStatistics([self.Y], self.statistics_cal, + self.backend, + n_samples=4, n_epochs=20, + n_samples_val=20, early_stopping=True, + use_tqdm=False) + self.statisticslearning_scale = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, scale_samples=False, + scale_parameters=True, use_tqdm=False) + self.statisticslearning_bounds = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + lower_bound_simulations=np.array([-1000, -1000, -1000]), + upper_bound_simulations=np.array([1000, 1000, 1000]), + use_tqdm=False, seed=1) + self.statisticslearning_no_schedulers = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + scheduler_parameters=False, + scheduler_simulations=False, use_tqdm=False) + + def test_initialization(self): + if not has_torch: + self.assertRaises(ImportError, ExpFamStatistics, [self.Y], self.statistics_cal, self.backend) + + def test_transformation(self): + if has_torch: + self.new_statistics_calculator = self.statisticslearning_all_defaults.get_statistics() + # with no scaler on data: + self.new_statistics_calculator_no_scaler = self.statisticslearning_scale.get_statistics() + # with no rescaling of the statistics: + self.new_statistics_calculator_no_rescale = self.statisticslearning_all_defaults.get_statistics( + rescale_statistics=False) + + # Simulate observed data + Obs = Normal([2, 4]) + y_obs = Obs.forward_simulate(Obs.get_input_values(), 1)[0].tolist() + + extracted_statistics = self.new_statistics_calculator.statistics(y_obs) + self.assertEqual(np.shape(extracted_statistics), (1, 2)) + extracted_statistics_no_rescale = self.new_statistics_calculator_no_rescale.statistics(y_obs) + self.assertEqual(np.shape(extracted_statistics_no_rescale), (1, 2)) + self.assertFalse(np.allclose(extracted_statistics_no_rescale, extracted_statistics)) + + self.assertRaises(RuntimeError, self.new_statistics_calculator.statistics, [np.array([1, 2])]) + self.assertRaises(RuntimeError, self.new_statistics_calculator_no_scaler.statistics, [np.array([1, 2])]) + + def test_errors(self): + if has_torch: + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, parameters=np.ones((100, 1))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, statistics_net=createDefaultNN(1, 3)) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, parameters_net=createDefaultNN(1, 3)) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, noise_type="ciao", use_tqdm=False) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, noise_type="sphere", variance_reduction=True, + use_tqdm=False) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, simulations=np.ones((100, 1))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations=np.ones((100, 1, 3))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters=np.ones((100, 1, 2))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, simulations=np.ones((100, 1)), + parameters=np.zeros((99, 1))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=np.ones((100, 1))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1, 3))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=np.ones((100, 1, 2))) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1)), + parameters_val=np.zeros((99, 1))) + with self.assertRaises(TypeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters=[i for i in range(10)], + simulations=[i for i in range(10)]) + with self.assertRaises(TypeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=[i for i in range(10)], + simulations_val=[i for i in range(10)]) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, lower_bound_simulations=[1, 2, 3]) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, upper_bound_simulations=[1, 2, 3]) + with self.assertRaises(RuntimeError): + self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, + lower_bound_simulations=np.array([-1000, -1000]), seed=1, + upper_bound_simulations=np.array([1000, 1000, 1000])) + + with self.assertRaises(RuntimeError): + self.statisticslearning_all_defaults.test_losses = [4, 2, 1] + self.statisticslearning_all_defaults.plot_losses() + with self.assertRaises(NotImplementedError): + self.statisticslearning_all_defaults.plot_losses(which_losses="foo") + + def test_plots(self): + if has_torch: + self.statisticslearning_all_defaults.plot_losses() + self.statisticslearning_all_defaults.plot_losses(which_losses="train") + self.statisticslearning_all_defaults.plot_losses(which_losses="test") + + if __name__ == '__main__': unittest.main() diff --git a/tests/transformers_tests.py b/tests/transformers_tests.py index 9dfa3d6..3fee3fc 100644 --- a/tests/transformers_tests.py +++ b/tests/transformers_tests.py @@ -2,7 +2,14 @@ import numpy as np -from abcpy.transformers import DummyTransformer, BoundedVarTransformer +from abcpy.transformers import DummyTransformer, BoundedVarTransformer, BoundedVarScaler + +try: + import torch +except ImportError: + has_torch = False +else: + has_torch = True class DummyTransformerTests(unittest.TestCase): @@ -53,5 +60,113 @@ def test_errors(self): self.transformer_two_sided.transform(x=[np.array([13.2]), np.array([2.4])]) +class test_BoundedVarScaler(unittest.TestCase): + + def setUp(self): + self.scaler_lower_bounded = BoundedVarScaler(lower_bound=np.array([0, 0]), + upper_bound=np.array([None, None])) + self.scaler_two_sided = BoundedVarScaler(lower_bound=np.array([0, 0]), upper_bound=np.array([10, 10])) + self.scaler_mixed = BoundedVarScaler(lower_bound=np.array([0, 0]), upper_bound=np.array([10, None])) + self.scaler_dummy = BoundedVarScaler(lower_bound=np.array([None, None]), + upper_bound=np.array([None, None])) + # without minmax + self.scaler_lower_bounded_no_minmax = BoundedVarScaler(lower_bound=np.array([0, 0]), + upper_bound=np.array([None, None]), + rescale_transformed_vars=False) + self.scaler_two_sided_no_minmax = BoundedVarScaler(lower_bound=np.array([0, 0]), upper_bound=np.array([10, 10]), + rescale_transformed_vars=False) + self.scaler_mixed_no_minmax = BoundedVarScaler(lower_bound=np.array([0, 0]), upper_bound=np.array([10, None]), + rescale_transformed_vars=False) + self.scaler_dummy_no_minmax = BoundedVarScaler(lower_bound=np.array([None, None]), + upper_bound=np.array([None, None]), + rescale_transformed_vars=False) + + self.list_scalers_minmax = [self.scaler_dummy, self.scaler_mixed, + self.scaler_two_sided, self.scaler_lower_bounded] + self.list_scalers_no_minmax = [self.scaler_dummy_no_minmax, self.scaler_mixed_no_minmax, + self.scaler_two_sided_no_minmax, self.scaler_lower_bounded_no_minmax] + + self.list_scalers = self.list_scalers_minmax + self.list_scalers_no_minmax + + # data + self.x = np.array([[3.2, 4.5]]) + self.x2 = np.array([[4.2, 3.5]]) + + def test(self): + for scaler in self.list_scalers: + scaler.fit(self.x) + self.assertEqual(self.x.shape, scaler.inverse_transform(scaler.transform(self.x)).shape) + self.assertTrue(np.allclose(np.array(self.x), np.array(scaler.inverse_transform(scaler.transform(self.x))))) + self.assertAlmostEqual(scaler.jac_log_det(self.x), + scaler.jac_log_det_inverse_transform(scaler.transform(self.x)), delta=1e-7) + + # test dummy scaler actually does nothing: + self.assertTrue(np.allclose(self.x, self.scaler_dummy_no_minmax.transform(self.x))) + self.assertTrue(np.allclose(self.x, self.scaler_dummy_no_minmax.inverse_transform(self.x))) + self.assertEqual(0, self.scaler_dummy.jac_log_det_inverse_transform(self.x)) + self.assertEqual(0, self.scaler_dummy.jac_log_det(self.x)) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det_inverse_transform(self.x)) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det(self.x)) + + # test that the jacobian works on 1d things as well: + self.assertEqual(0, self.scaler_dummy.jac_log_det_inverse_transform(self.x.squeeze())) + self.assertEqual(0, self.scaler_dummy.jac_log_det(self.x.squeeze())) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det_inverse_transform(self.x.squeeze())) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det(self.x.squeeze())) + + def test_torch(self): + # same as test but using torch input + if has_torch: + x_torch = torch.from_numpy(self.x) + for scaler in self.list_scalers: + scaler.fit(x_torch) + self.assertEqual(x_torch.shape, scaler.inverse_transform(scaler.transform(x_torch)).shape) + self.assertTrue(np.allclose(self.x, np.array(scaler.inverse_transform(scaler.transform(x_torch))))) + self.assertAlmostEqual(scaler.jac_log_det(x_torch), + scaler.jac_log_det_inverse_transform(scaler.transform(x_torch)), delta=1e-7) + + # test dummy scaler actually does nothing: + self.assertTrue(np.allclose(x_torch, self.scaler_dummy_no_minmax.transform(x_torch))) + self.assertTrue(np.allclose(x_torch, self.scaler_dummy_no_minmax.inverse_transform(x_torch))) + self.assertEqual(0, self.scaler_dummy.jac_log_det_inverse_transform(x_torch)) + self.assertEqual(0, self.scaler_dummy.jac_log_det(x_torch)) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det_inverse_transform(x_torch)) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det(x_torch)) + + # test that the jacobian works on 1d things as well: + self.assertEqual(0, self.scaler_dummy.jac_log_det_inverse_transform(x_torch.squeeze())) + self.assertEqual(0, self.scaler_dummy.jac_log_det(x_torch.squeeze())) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det_inverse_transform(x_torch.squeeze())) + self.assertEqual(0, self.scaler_dummy_no_minmax.jac_log_det(x_torch.squeeze())) + + def test_jacobian_difference(self): + # the values of the jacobian log det do not take into account the linear transformation as what + # really matters are the difference between them for two x values (in an MCMC acceptance rate). + # Then the difference of the jacobian for the same two points in original and transformed space should be + # the same. + for scaler_minmax, scaler_no_minmax in zip(self.list_scalers_minmax, self.list_scalers_no_minmax): + scaler_minmax.fit(self.x) + scaler_no_minmax.fit(self.x) + + # the difference of the log det of jacobian between two points in the original space should be the same + self.assertAlmostEqual( + scaler_minmax.jac_log_det(self.x) - scaler_minmax.jac_log_det(self.x2), + scaler_no_minmax.jac_log_det(self.x) - scaler_no_minmax.jac_log_det(self.x2), + delta=1e-7) + + # the difference of the log det of jacobian between two points corresponding to the same two points in the + # original space (either if the linear rescaling is applied or not) should be the same + self.assertAlmostEqual( + scaler_minmax.jac_log_det_inverse_transform(scaler_minmax.transform(self.x)) - + scaler_minmax.jac_log_det_inverse_transform(scaler_minmax.transform(self.x2)), + scaler_no_minmax.jac_log_det_inverse_transform(scaler_no_minmax.transform(self.x)) - + scaler_no_minmax.jac_log_det_inverse_transform(scaler_no_minmax.transform(self.x2)), + delta=1e-7) + + def test_errors(self): + with self.assertRaises(RuntimeError): + self.scaler_mixed.jac_log_det(np.array([[1.1, 2.2], [3.3, 4.4]])) + + if __name__ == '__main__': unittest.main() From f14bce36ca91a1fd0e5a90fa4308534dc04bb215 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Tue, 24 Aug 2021 17:59:46 +0100 Subject: [PATCH 26/34] Fix tests if no torch is available Small fix Small fix Small fix --- abcpy/statisticslearning.py | 24 ++++--- abcpy/transformers.py | 16 +++-- tests/NN_utilities_networks_tests.py | 83 ++++++++++++----------- tests/NN_utilities_utilities_tests.py | 98 +++++++++++++++------------ 4 files changed, 122 insertions(+), 99 deletions(-) diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index 39f845a..4712868 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -24,10 +24,11 @@ from abcpy.statistics import NeuralEmbedding from torch.optim import Adam, lr_scheduler import torch.autograd as autograd + from abcpy.NN_utilities.utilities import jacobian_second_order, set_requires_grad + from abcpy.NN_utilities.losses import Fisher_divergence_loss_with_c_x from abcpy.NN_utilities.algorithms import FP_nn_training, triplet_training, contrastive_training -from abcpy.NN_utilities.utilities import compute_similarity_matrix, jacobian_second_order, set_requires_grad -from abcpy.NN_utilities.losses import Fisher_divergence_loss_with_c_x +from abcpy.NN_utilities.utilities import compute_similarity_matrix # TODO: there seems to be issue when n_samples_per_param >1. Check that. Should you modify the _sample_parameters-statistics function? @@ -978,7 +979,7 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet cuda=None, load_all_data_GPU=False, seed=None, - nonlinearity_statistics=torch.nn.Softplus, nonlinearity_parameters=torch.nn.ReLU, + nonlinearity_statistics=None, nonlinearity_parameters=None, batch_norm=True, batch_norm_momentum=0.1, batch_norm_update_before_test=False, lr_simulations=1e-3, lr_parameters=1e-3, lam=0, @@ -1123,6 +1124,8 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet lower_bound_simulations = np.array([None] * simulations.shape[1]) if upper_bound_simulations is None: upper_bound_simulations = np.array([None] * simulations.shape[1]) + # if both bounds are None this scaler will just behave as a MinMaxScaler. It may be slightly efficient to + # use that, but it does not matter for now. self.scaler_simulations = BoundedVarScaler(lower_bound_simulations, upper_bound_simulations, rescale_transformed_vars=self.scale_samples).fit(simulations) simulations = self.scaler_simulations.transform(simulations) @@ -1158,10 +1161,9 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet elif isinstance(statistics_net, list) or statistics_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.statistics_net = createDefaultNNWithDerivatives(input_size=simulations.shape[1], - output_size=embedding_dimension + 1, - hidden_sizes=statistics_net, - nonlinearity=nonlinearity_statistics)() + self.statistics_net = createDefaultNNWithDerivatives( + input_size=simulations.shape[1], output_size=embedding_dimension + 1, hidden_sizes=statistics_net, + nonlinearity=torch.nn.Softplus if nonlinearity_statistics is None else nonlinearity_statistics)() self.logger.debug('We generate a default neural network for the summary statistics') else: raise RuntimeError("'statistics_net' needs to be either a torch.nn.Module, or a list, or None.") @@ -1173,10 +1175,10 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet elif isinstance(parameters_net, list) or parameters_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.parameters_net = createDefaultNN(input_size=parameters.shape[1], output_size=embedding_dimension, - hidden_sizes=parameters_net, nonlinearity=nonlinearity_parameters(), - batch_norm_last_layer=batch_norm, - batch_norm_last_layer_momentum=batch_norm_momentum)() + self.parameters_net = createDefaultNN( + input_size=parameters.shape[1], output_size=embedding_dimension, hidden_sizes=parameters_net, + nonlinearity=torch.nn.ReLU() if nonlinearity_parameters is None else nonlinearity_parameters(), + batch_norm_last_layer=batch_norm, batch_norm_last_layer_momentum=batch_norm_momentum)() self.logger.debug('We generate a default neural network for the parameters') else: raise RuntimeError("'parameters_net' needs to be either a torch.nn.Module, or a list, or None.") diff --git a/abcpy/transformers.py b/abcpy/transformers.py index 9a62d01..89b3f5a 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -1,7 +1,13 @@ -import torch import numpy as np from sklearn.preprocessing import MinMaxScaler +try: + import torch +except ImportError: + has_torch = False +else: + has_torch = True + # The first two transformers are used in the MCMC inference scheme, in order to run MCMC of an unbounded transformed # space in case the original space is bounded. It therefore also implements the jacobian terms which appear in @@ -307,7 +313,7 @@ def fit(self, X, y=None): Fitted scaler. """ # need to check if we can apply the log first: - if isinstance(X, torch.Tensor): + if has_torch and isinstance(X, torch.Tensor): X = X.detach().numpy() self._check_data_in_bounds(X) @@ -331,7 +337,7 @@ def transform(self, X): Transformed data. """ # need to check if we can apply the log first: - if isinstance(X, torch.Tensor): + if has_torch and isinstance(X, torch.Tensor): X = X.detach().numpy() self._check_data_in_bounds(X) @@ -378,7 +384,7 @@ def jac_log_det(self, x): res : float log determinant of the jacobian """ - if isinstance(x, torch.Tensor): + if has_torch and isinstance(x, torch.Tensor): x = x.detach().numpy() x = self._check_reshape_single_sample(x) self._check_data_in_bounds(x.reshape(1, -1)) @@ -403,7 +409,7 @@ def jac_log_det_inverse_transform(self, x): res : float log determinant of the jacobian evaluated in :math:`t^{-1}(x)` """ - if isinstance(x, torch.Tensor): + if has_torch and isinstance(x, torch.Tensor): x = x.detach().numpy() if self.rescale_transformed_vars: diff --git a/tests/NN_utilities_networks_tests.py b/tests/NN_utilities_networks_tests.py index 11cae29..0f6a773 100644 --- a/tests/NN_utilities_networks_tests.py +++ b/tests/NN_utilities_networks_tests.py @@ -13,62 +13,69 @@ class test_default_NN_with_derivatives(unittest.TestCase): def setUp(self): - self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus)() - self.net_first_der_only = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus, - first_derivative_only=True)() - self.tensor = torch.randn((10, 5), requires_grad=True) + if has_torch: + self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus)() + self.net_first_der_only = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softplus, + first_derivative_only=True)() + self.tensor = torch.randn((10, 5), requires_grad=True) def test_first_der(self): - # compute derivative with forward pass - y, f1 = self.net_first_der_only.forward_and_derivatives(self.tensor) - f2 = jacobian(self.tensor, y) + if has_torch: + # compute derivative with forward pass + y, f1 = self.net_first_der_only.forward_and_derivatives(self.tensor) + f2 = jacobian(self.tensor, y) - assert torch.allclose(f1, f2) + assert torch.allclose(f1, f2) def test_first_and_second_der(self): - # compute derivative with forward pass - y, f1, s1 = self.net.forward_and_derivatives(self.tensor) - f2, s2 = jacobian_second_order(self.tensor, y) + if has_torch: + # compute derivative with forward pass + y, f1, s1 = self.net.forward_and_derivatives(self.tensor) + f2, s2 = jacobian_second_order(self.tensor, y) - assert torch.allclose(f1, f2) - assert torch.allclose(s1, s2) + assert torch.allclose(f1, f2) + assert torch.allclose(s1, s2) def test_first_der_and_hessian(self): - # compute derivative with forward pass - y, f1, H1 = self.net.forward_and_full_derivatives(self.tensor) - f2, H2 = jacobian_hessian(self.tensor, y) + if has_torch: + # compute derivative with forward pass + y, f1, H1 = self.net.forward_and_full_derivatives(self.tensor) + f2, H2 = jacobian_hessian(self.tensor, y) - assert torch.allclose(f1, f2) - assert torch.allclose(H1, H2) + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) def test_error(self): - with self.assertRaises(RuntimeError): - self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softsign)() + if has_torch: + with self.assertRaises(RuntimeError): + self.net = createDefaultNNWithDerivatives(5, 2, nonlinearity=torch.nn.Softsign)() class test_discard_last_output_wrapper(unittest.TestCase): def setUp(self): - self.net = createDefaultNN(2, 3)() - self.net_with_discard_wrapper = DiscardLastOutputNet(self.net) - # reference input and output - torch.random.manual_seed(1) - self.tensor_1 = torch.randn(2) - self.tensor_2 = torch.randn(1, 2) - self.tensor_3 = torch.randn(1, 3, 2) + if has_torch: + self.net = createDefaultNN(2, 3)() + self.net_with_discard_wrapper = DiscardLastOutputNet(self.net) + # reference input and output + torch.random.manual_seed(1) + self.tensor_1 = torch.randn(2) + self.tensor_2 = torch.randn(1, 2) + self.tensor_3 = torch.randn(1, 3, 2) def test_output(self): - out = self.net(self.tensor_1) - out_discard = self.net_with_discard_wrapper(self.tensor_1) - self.assertTrue(torch.allclose(out[:-1], out_discard)) - - out = self.net(self.tensor_2) - out_discard = self.net_with_discard_wrapper(self.tensor_2) - self.assertTrue(torch.allclose(out[:, :-1], out_discard)) - - out = self.net(self.tensor_3) - out_discard = self.net_with_discard_wrapper(self.tensor_3) - self.assertTrue(torch.allclose(out[:, :, :-1], out_discard)) + if has_torch: + out = self.net(self.tensor_1) + out_discard = self.net_with_discard_wrapper(self.tensor_1) + self.assertTrue(torch.allclose(out[:-1], out_discard)) + + out = self.net(self.tensor_2) + out_discard = self.net_with_discard_wrapper(self.tensor_2) + self.assertTrue(torch.allclose(out[:, :-1], out_discard)) + + out = self.net(self.tensor_3) + out_discard = self.net_with_discard_wrapper(self.tensor_3) + self.assertTrue(torch.allclose(out[:, :, :-1], out_discard)) if __name__ == '__main__': diff --git a/tests/NN_utilities_utilities_tests.py b/tests/NN_utilities_utilities_tests.py index 862b388..37663af 100644 --- a/tests/NN_utilities_utilities_tests.py +++ b/tests/NN_utilities_utilities_tests.py @@ -19,73 +19,81 @@ class test_jacobian_functions(unittest.TestCase): # it does not test that the derivatives numerical errors are correct but they are. def setUp(self): - net = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=False)() - net_bn = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=True)() - self.tensor = torch.randn((10, 5), requires_grad=True) - self.y = net(self.tensor) - self.y_bn = net_bn(self.tensor) + if has_torch: + net = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=False)() + net_bn = createDefaultNN(5, 2, nonlinearity=torch.nn.Softplus(), batch_norm_last_layer=True)() + self.tensor = torch.randn((10, 5), requires_grad=True) + self.y = net(self.tensor) + self.y_bn = net_bn(self.tensor) - self.y_with_infinities = self.y.detach().clone() - self.y_with_infinities[0, 0] = np.inf + self.y_with_infinities = self.y.detach().clone() + self.y_with_infinities[0, 0] = np.inf - self.f, self.s = jacobian_second_order(self.tensor, self.y) # reference derivatives - self.f_bn, self.s_bn = jacobian_second_order(self.tensor, self.y_bn) # reference derivatives + self.f, self.s = jacobian_second_order(self.tensor, self.y) # reference derivatives + self.f_bn, self.s_bn = jacobian_second_order(self.tensor, self.y_bn) # reference derivatives def test_first_der(self): - # compute derivative with forward pass - f2 = jacobian(self.tensor, self.y, diffable=False) + if has_torch: + # compute derivative with forward pass + f2 = jacobian(self.tensor, self.y, diffable=False) - assert torch.allclose(self.f, f2) + assert torch.allclose(self.f, f2) def test_first_and_second_der(self): - # compute derivative with forward pass - f2, s2 = jacobian_second_order(self.tensor, self.y, diffable=False) + if has_torch: + # compute derivative with forward pass + f2, s2 = jacobian_second_order(self.tensor, self.y, diffable=False) - assert torch.allclose(self.f, f2) - assert torch.allclose(self.s, s2) + assert torch.allclose(self.f, f2) + assert torch.allclose(self.s, s2) def test_first_der_and_hessian(self): - # compute derivative with forward pass - f1, H1 = jacobian_hessian(self.tensor, self.y) - f2, H2 = jacobian_hessian(self.tensor, self.y, diffable=False) - s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix + if has_torch: + # compute derivative with forward pass + f1, H1 = jacobian_hessian(self.tensor, self.y) + f2, H2 = jacobian_hessian(self.tensor, self.y, diffable=False) + s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix - assert torch.allclose(self.f, f2) - assert torch.allclose(f1, f2) - assert torch.allclose(H1, H2) - assert torch.allclose(self.s, s2) + assert torch.allclose(self.f, f2) + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) + assert torch.allclose(self.s, s2) def test_first_der_bn(self): - # compute derivative with forward pass - f2 = jacobian(self.tensor, self.y_bn, diffable=False) + if has_torch: + # compute derivative with forward pass + f2 = jacobian(self.tensor, self.y_bn, diffable=False) - assert torch.allclose(self.f_bn, f2) + assert torch.allclose(self.f_bn, f2) def test_first_and_second_der_bn(self): - # compute derivative with forward pass - f2, s2 = jacobian_second_order(self.tensor, self.y_bn, diffable=False) + if has_torch: + # compute derivative with forward pass + f2, s2 = jacobian_second_order(self.tensor, self.y_bn, diffable=False) - assert torch.allclose(self.f_bn, f2) - assert torch.allclose(self.s_bn, s2) + assert torch.allclose(self.f_bn, f2) + assert torch.allclose(self.s_bn, s2) def test_first_der_and_hessian_bn(self): - # compute derivative with forward pass - f1, H1 = jacobian_hessian(self.tensor, self.y_bn) - f2, H2 = jacobian_hessian(self.tensor, self.y_bn, diffable=False) - s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix + if has_torch: + # compute derivative with forward pass + f1, H1 = jacobian_hessian(self.tensor, self.y_bn) + f2, H2 = jacobian_hessian(self.tensor, self.y_bn, diffable=False) + s2 = torch.einsum('biik->bik', H2) # obtain the second order jacobian from Hessian matrix - assert torch.allclose(self.f_bn, f2) - assert torch.allclose(f1, f2) - assert torch.allclose(H1, H2) - assert torch.allclose(self.s_bn, s2) + assert torch.allclose(self.f_bn, f2) + assert torch.allclose(f1, f2) + assert torch.allclose(H1, H2) + assert torch.allclose(self.s_bn, s2) def test_errors(self): - with self.assertRaises(ValueError): - f1 = jacobian(self.tensor, self.y_with_infinities) - with self.assertRaises(ValueError): - f1, s1 = jacobian_second_order(self.tensor, self.y_with_infinities) - with self.assertRaises(ValueError): - f1, H1 = jacobian_hessian(self.tensor, self.y_with_infinities) + if has_torch: + with self.assertRaises(ValueError): + f1 = jacobian(self.tensor, self.y_with_infinities) + with self.assertRaises(ValueError): + f1, s1 = jacobian_second_order(self.tensor, self.y_with_infinities) + with self.assertRaises(ValueError): + f1, H1 = jacobian_hessian(self.tensor, self.y_with_infinities) if __name__ == '__main__': From 3a392b8bed011db7d1689587eaebe48849fd5a3c Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Wed, 25 Aug 2021 18:01:05 +0100 Subject: [PATCH 27/34] Docstrings and small refactor --- abcpy/NN_utilities/networks.py | 66 ++-- abcpy/statisticslearning.py | 570 ++++++++++++++++++++---------- abcpy/transformers.py | 71 ++-- tests/statisticslearning_tests.py | 7 +- 4 files changed, 469 insertions(+), 245 deletions(-) diff --git a/abcpy/NN_utilities/networks.py b/abcpy/NN_utilities/networks.py index ebbd4a5..7dbaf1e 100644 --- a/abcpy/NN_utilities/networks.py +++ b/abcpy/NN_utilities/networks.py @@ -43,6 +43,40 @@ def get_embedding(self, x): return self.embedding_net(x) +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) + + +class DiscardLastOutputNet(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. Next, the """ + + def __init__(self, net): + super().__init__() + self.net = net + + def forward(self, x): + x = self.net(x) + if len(x.shape) == 1: + return x[0:-1] + if len(x.shape) == 2: + return x[:, 0:-1] + if len(x.shape) == 3: + return x[:, :, 0:-1] + + def createDefaultNN(input_size, output_size, hidden_sizes=None, nonlinearity=None, batch_norm_last_layer=False, batch_norm_last_layer_momentum=0.1): """Function returning a fully connected neural network class with a given input and output size, and optionally @@ -287,35 +321,3 @@ def forward_and_full_derivatives(self, x): return x, f.transpose(0, 1), H.transpose(0, 2) return DefaultNNWithDerivatives - - -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) - - -class DiscardLastOutputNet(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. Next, the """ - - def __init__(self, net): - super().__init__() - self.net = net - - def forward(self, x): - x = self.net(x) - if len(x.shape) == 1: - return x[0:-1] - if len(x.shape) == 2: - return x[:, 0:-1] - if len(x.shape) == 3: - return x[:, :, 0:-1] diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index 4712868..7b4edb8 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -76,7 +76,8 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_va 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 to generate the training data. Default value is None. + other simulations are performed to generate the training data. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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 @@ -85,7 +86,8 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_va 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 + `parameters_val`, in which case no other simulations are performed to generate the validation set. + These are transformed by the `statistics_calc` statistics before the learning step is done. Default value is None. seed: integer, optional Optional initial seed for the random number generator. The default value is generated randomly. @@ -231,8 +233,8 @@ def plot_losses(self, which_losses="both"): ---------- which_losses: string, optional Specifies which set of losses to display (between training and test loss). - Can be "train", "test" or "both". Notice that the test loss could be unavailable (in case no test set was - used for training), in which case the test loss is not shown even if requested. Defaults to "both". + Can be 'train', 'test' or 'both'. Notice that the test loss could be unavailable (in case no test set was + used for training), in which case the test loss is not shown even if requested. Defaults to 'both'. Returns ------- @@ -276,7 +278,7 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -294,7 +296,8 @@ def __init__(self, model, statistics_calc, backend, n_samples=1000, n_samples_pe 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. These are transformed by the + `statistics_calc` statistics before the learning step is done. Default value is None. seed: integer, optional Optional initial seed for the random number generator. The default value is generated randomly. """ @@ -329,7 +332,10 @@ class StatisticsLearningNN(StatisticsLearningWithLosses, 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. - In order to use this technique, Pytorch is required to handle the neural networks. + In order to use this technique, Pytorch is required to handle the neural networks. However, the user does not need + to be fluent in Pytorch as some default neural networks are instantiated if the user does not provide them + (experienced users can of course provide the neural networks they would like to use). GPUs can be used to + train the neural networks if required. """ def __init__(self, model, statistics_calc, backend, training_routine, distance_learning, embedding_net=None, @@ -341,7 +347,7 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -382,12 +388,14 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l 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 to generate the training data. Default value is None. + other simulations are performed to generate the training data. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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`, in which case no other simulations are performed to generate the validation set. + These are transformed by the + `statistics_calc` statistics before the learning step is done. 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 @@ -401,9 +409,8 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l 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. + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming 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. @@ -511,11 +518,11 @@ def __init__(self, model, statistics_calc, backend, training_routine, distance_l def get_statistics(self): """ - Returns a NeuralEmbedding Statistics implementing the learned transformation. + Returns a :class:`abcpy.statistics.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. + If a scaler was used, the `net` attribute of the returned object is of the class + :class:`abcpy.NN_utilities.networks.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 ------- @@ -535,7 +542,10 @@ class SemiautomaticNN(StatisticsLearningNN): """This class implements the semi automatic summary statistics learning technique as described in Jiang et al. 2017 [1]. - In order to use this technique, Pytorch is required to handle the neural networks. + In order to use this technique, Pytorch is required to handle the neural networks. However, the user does not need + to be fluent in Pytorch as some default neural networks are instantiated if the user does not provide them + (experienced users can of course provide the neural networks they would like to use). GPUs can be used to + train the neural networks if required. [1] Jiang, B., Wu, T.Y., Zheng, C. and Wong, W.H., 2017. Learning summary statistic for approximate Bayesian computation via deep neural network. Statistica Sinica, pp.1595-1618. @@ -552,7 +562,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -586,7 +596,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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 to generate the training data. Default value is None. + other simulations are performed to generate the training data. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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 @@ -595,8 +606,9 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + `parameters_val`, in which case no other simulations are performed to generate the validation set. + These are transformed by the `statistics_calc` statistics before the learning step is done. + 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 @@ -604,8 +616,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + training or not. Namely, if `epochs_early_stopping_interval=10`, early stopping can happen only at epochs + multiple of 10. Default 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. @@ -617,9 +629,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming 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. @@ -645,8 +656,6 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. use_tqdm : boolean, optional Whether using tqdm or not to display progress. Defaults to True. optimizer_kwargs: Python dictionary, optional @@ -675,15 +684,18 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample class TripletDistanceLearning(StatisticsLearningNN): """This class implements the statistics learning technique by using the triplet loss [1] for distance learning as - described in Pacchiardi et al. 2019 [2]. + described in Pacchiardi et al. 2021 [2]. - In order to use this technique, Pytorch is required to handle the neural networks. + In order to use this technique, Pytorch is required to handle the neural networks. However, the user does not need + to be fluent in Pytorch as some default neural networks are instantiated if the user does not provide them + (experienced users can of course provide the neural networks they would like to use). GPUs can be used to + train the neural networks if required. [1] Schroff, F., Kalenichenko, D. and Philbin, J., 2015. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 815-823). - [2] Pacchiardi, L., Kunzli, P., Schoengens, M., Chopard, B. and Dutta, R., 2019. Distance-learning For Approximate - Bayesian Computation To Model a Volcanic Eruption. arXiv preprint arXiv:1909.13118. + [2] Pacchiardi, L., Kunzli, P., Schöngens, M., Chopard, B., and Dutta, R., 2021. Distance-learning for + approximate bayesian computation to model a volcanic eruption. Sankhya B, 83(1), 288-317. """ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0, @@ -698,7 +710,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -732,7 +744,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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 to generate the training data. Default value is None. + other simulations are performed to generate the training data. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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 @@ -741,8 +754,9 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + `parameters_val`, in which case no other simulations are performed to generate the validation set. + These are transformed by the `statistics_calc` statistics before the learning step is done. + 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 @@ -751,7 +765,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + multiple of 10. Default 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. @@ -763,9 +777,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming 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. @@ -796,8 +809,6 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. use_tqdm : boolean, optional Whether using tqdm or not to display progress. Defaults to True. optimizer_kwargs: Python dictionary, optional @@ -830,16 +841,19 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample class ContrastiveDistanceLearning(StatisticsLearningNN): """This class implements the statistics learning technique by using the contrastive loss [1] for distance learning - as described in Pacchiardi et al. 2019 [2]. + as described in Pacchiardi et al. 2021 [2]. - In order to use this technique, Pytorch is required to handle the neural networks. + In order to use this technique, Pytorch is required to handle the neural networks. However, the user does not need + to be fluent in Pytorch as some default neural networks are instantiated if the user does not provide them + (experienced users can of course provide the neural networks they would like to use). GPUs can be used to + train the neural networks if required. [1] Hadsell, R., Chopra, S. and LeCun, Y., 2006, June. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'06) (Vol. 2, pp. 1735-1742). IEEE. - [2] Pacchiardi, L., Kunzli, P., Schoengens, M., Chopard, B. and Dutta, R., 2019. Distance-learning For Approximate - Bayesian Computation To Model a Volcanic Eruption. arXiv preprint arXiv:1909.13118. + [2] Pacchiardi, L., Kunzli, P., Schöngens, M., Chopard, B., and Dutta, R., 2021. Distance-learning for + approximate bayesian computation to model a volcanic eruption. Sankhya B, 83(1), 288-317. """ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_samples=1000, n_samples_val=0, @@ -853,7 +867,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. @@ -873,6 +887,10 @@ 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. @@ -883,7 +901,31 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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. + These are transformed by the `statistics_calc` statistics before the learning step is done. + 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. Default 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 @@ -892,9 +934,8 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming 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. @@ -929,8 +970,6 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample 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. use_tqdm : boolean, optional Whether using tqdm or not to display progress. Defaults to True. optimizer_kwargs: Python dictionary, optional @@ -965,28 +1004,50 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample class ExpFamStatistics(StatisticsLearningWithLosses, GraphTools): - def __init__(self, model, statistics_calc, backend, statistics_net=None, parameters_net=None, + """This class implements the statistics learning technique using exponential family as described in Pacchiardi et + al. 2020 [1]. Specifically, the idea is to fit an exponential family to a set of parameter-simulation pairs from + the model, with two neural networks representing the summary statistics and the natural parameters of the + exponential family. Once the neural networks have been fit, the one representing summary statistics is can be used + in ABC. + + In order to fit the exponential family (which has an intractable normalization constant), the class relies on + Score Matching [2] or on Sliced Score Matching [3], which is a faster stochastic version of the former. + + As Score Matching and its sliced version work on an unbounded simulation space, in case the simulations from the + model are unbounded, they need to be transformed to an unbounded space. This class takes care of this step, provided + that the user specifies the simulation bounds in the `lower_bound_simulations` and `upper_bound_simulations` + arguments. + + In order to use this technique, Pytorch is required to handle the neural networks. However, the user does not need + to be fluent in Pytorch as some default neural networks are instantiated if the user does not provide them + (experienced users can of course provide the neural networks they would like to use). GPUs can be used to + train the neural networks if required. + + [1] Pacchiardi, L., and Dutta, R., 2020. Score Matched Conditional Exponential Families for + Likelihood-Free Inference. arXiv preprint arXiv:2012.10903. + + [2] Hyvärinen, A., and Dayan, P., 2005. Estimation of non-normalized statistical models by score matching. + Journal of Machine Learning Research, 6(4). + + [3] Song, Y., Garg, S., Shi, J. and Ermon, S., 2019. Sliced score matching: A scalable approach to + density and score estimation. arXiv preprint arXiv:1905.07088, 2019 + """ + + def __init__(self, model, statistics_calc, backend, simulations_net=None, parameters_net=None, embedding_dimension=None, n_samples=1000, n_samples_val=0, parameters=None, simulations=None, parameters_val=None, simulations_val=None, lower_bound_simulations=None, upper_bound_simulations=None, - sliced=True, noise_type='radermacher', variance_reduction=False, - n_epochs=100, batch_size=16, scale_samples=True, scale_parameters=False, early_stopping=False, epochs_early_stopping_interval=1, start_epoch_early_stopping=10, - cuda=None, load_all_data_GPU=False, - - seed=None, - nonlinearity_statistics=None, nonlinearity_parameters=None, + cuda=None, load_all_data_GPU=False, seed=None, + nonlinearity_simulations=None, nonlinearity_parameters=None, batch_norm=True, batch_norm_momentum=0.1, batch_norm_update_before_test=False, - lr_simulations=1e-3, lr_parameters=1e-3, lam=0, - + lr_simulations=1e-3, lr_parameters=1e-3, lam=0.0, optimizer_simulations=None, optimizer_parameters=None, - scheduler_simulations=None, scheduler_parameters=None, - - start_epoch_training=0, + scheduler_simulations=None, scheduler_parameters=None, start_epoch_training=0, optimizer_simulations_kwargs={}, optimizer_parameters_kwargs={}, scheduler_simulations_kwargs={}, scheduler_parameters_kwargs={}, use_tqdm=True): @@ -995,22 +1056,52 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet ---------- model: abcpy.models.Model Model object that conforms to the Model class. - statistics_cal: abcpy.statistics.Statistics + statistics_calc: abcpy.statistics.Statistics Statistics object that conforms to the Statistics class, applied before learning the transformation. backend: abcpy.backends.Backend Backend object that conforms to the Backend class. - embedding_net: torch.nn object or list - it can be a torch.nn object with input size corresponding to size of model output - (after being transformed by `statistics_calc`), alternatively, a list + simulations_net: torch.nn object or list, optional + The neural network which transforms the simulations to the summary statistics of the exponential family. + At the end of the training routine, the output of `simulations_net` (except for the last component) + will be the learned summary statistics. + It can be a torch.nn object with input size corresponding to size of model output + (after being transformed by `statistics_calc`) or, alternatively, a list with integer numbers denoting the width of the hidden layers, from which a fully connected network with - that structure is created, having the input and output size corresponding to size of model output - (after being transformed by `statistics_calc`) and - number of parameters. In case this is None, a fully connected neural network with three hidden layers is - used; the width of the hidden layers is given by + that structure is created, having the input size corresponding to size of model output + (after being transformed by `statistics_calc`) and the output size determined by + `embedding_dimension` (see below). Importantly, the output size of `simulations_net` needs to be equal to + the output size of `parameters_net` increased by one, as the two are used together in the code. If both nets + are left to their default values, this is done automatically. + In case this is None, a fully connected neural network with three + hidden layers is used; the width of the hidden layers is given by ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, - where `input_size` is the size of the data after being transformed by `statistics_calc`, while `output_size` - is the number of parameters in the model. For further details check - :func:`abcpy.NN_utilities.networks.createDefaultNN` + where `input_size` is the size of the data after being transformed by `statistics_calc`, while + `output_size` is determined by `embedding_dimension`. For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN`. By default, this is None. + parameters_net: torch.nn object or list, optional + The neural network which maps the parameters to the natural parametrization form of the exponential family. + It can be a torch.nn object with input size corresponding to the number of parameters + or, alternatively, a list + with integer numbers denoting the width of the hidden layers, from which a fully connected network with + that structure is created, having the input size corresponding to the number of parameters + and the output size determined by + `embedding_dimension` (see below). Importantly, the output size of `parameters_net` needs to be equal to + the output size of `simulations_net` decreased by one, as the two are used together in the code. + If both nets are left to their default values, this is done automatically. + In case this is None, a fully connected neural network with three + hidden layers is used; the width of the hidden layers is given by + ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``, + where `input_size` is the number of parameters, while `output_size` is determined by `embedding_dimension`. + For further details check + :func:`abcpy.NN_utilities.networks.createDefaultNN`. By default, this is None. + embedding_dimension: integer, optional + Size of the learned summary statistics if `simulations_net` is None or a list. + Specifically, in these cases + `simulations_net` is automatically created having output size `embedding_dimension + 1`, of which all but + the latter components will represent the learned summaries (the latter instead is a learned base measure). + If also `parameters_net` is None or a list, it will be automatically created with output size equal to + `embedding_dimension`. By default `embedding_dimension` is None, in which case it is fixed to the number + of parameters in the model. n_samples: int, optional The number of (parameter, simulated data) tuple to be generated to learn the summary statistics in pilot step. The default value is 1000. @@ -1019,9 +1110,6 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet 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 @@ -1029,7 +1117,8 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet 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 to generate the training data. Default value is None. + other simulations are performed to generate the training data. These are transformed by the + `statistics_calc` statistics before the learning step is done. 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 @@ -1040,21 +1129,144 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet 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 - If cuda=None, it will select GPU if it is available. Or you can specify True to use GPU or False to use CPU + lower_bound_simulations: np.ndarray, optional + Array of the same length of the simulations on which the statistics will be learned (therefore, after + `statistics_calc` has been applied). It contains the lower bounds of the simulations, with each entry + being either None or a number. It works together with `upper_bound_simulations` to determine the + nonlinear transformation mapping the bounded space to an unbounded one: if both upper and lower + bounds for a given entry are None, no transformation is applied to that entry. If both of them are numbers, + a transformation mapping a compact domain to an unbounded one is applied. If instead the lower bound is a + number and the upper one is None, a transformation for lower bounded variables is applied. More details on + the transformations can be found at :class:`abcpy.transformers.BoundedVarTransformer`. By default, + `lower_bound_simulations` is None, in which case all variables are assumed to not be lower bounded. + upper_bound_simulations: np.ndarray, optional + Array of the same length of the simulations on which the statistics will be learned (therefore, after + `statistics_calc` has been applied). It contains the upper bounds of the simulations, with each entry + being either None or a number. It works together with `lower_bound_simulations` to determine the + nonlinear transformation mapping the bounded space to an unbounded one: if both upper and lower + bounds for a given entry are None, no transformation is applied to that entry. If both of them are numbers, + a transformation mapping a compact domain to an unbounded one is applied. If instead the lower bound is a + number and the upper one is None, a transformation for lower bounded variables is applied. More details on + the transformations can be found at :class:`abcpy.transformers.BoundedVarTransformer`. By default, + `upper_bound_simulations` is None, in which case all variables are assumed to not be upper bounded. + sliced: boolean, optional + If True, the exponential family is fit with the sliced Score Matching approach, which is a faster + (stochastic) version of Score Matching. If False, the full Score Matching approach is used. Default is True. + noise_type: basestring, optional + Denotes the noise type used in the sliced Score Matching version. It can be 'radermacher', 'gaussian' or + 'sphere', with 'radermacher' being the default one. Ignored if `sliced=False`. + variance_reduction: boolean, optional + If True, use the variance reduction version of Sliced Score Matching (when that is used), which replaces a + term with its exact expectation over the noise distribution. Cannot be used when `noise=sphere`. + Default is False, ignored if `sliced=False`. + n_epochs: integer, optional + the number of epochs used for training the neural network. Default is 100 + batch_size: integer, optional + the batch size used for training the neural network. Default is 16 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. + If True, the simulations are scaled to the (0,1) range before the transformation is learned (i.e., before + being fed to the neural network). This happens after the simulations have been transformed with + `statistics_calc` and after the (optional) nonlinear transformation governed by `lower_bound_simulations` + and `upper_bound_simulations` is applied. This relies on a wrapping of `sklearn.preprocessing.MinMaxScaler`. + The validation set will also be rescaled in the same fashion. + When calling the `get_statistics` and the `get_simulations_network` methods, + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming 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. + scale_parameters: boolean, optional + If True, the parameters are scaled to the (0,1) range before the natural parameters transformation + is learned (i.e., before being fed to the neural network). + This relies on a wrapping of `sklearn.preprocessing.MinMaxScaler`. + The validation set will also be rescaled in the same fashion. + When calling the `get_statistics` and the `get_parameters_network` methods, + the network will be wrapped by :class:`abcpy.NN_utilities.networks.ScalerAndNet`; this automatically + takes care of transforming the data with the scaler before applying the neural network. + For parameter, the scaler is not as critical as for simulations, as parameters usually have smaller ranges. + If however the different parameters differ by orderd of magnitude, using a scaler is recommended. + Default value is False. + 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. Default 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. + 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 + load_all_data_GPU: boolean, optional + If True and if we a GPU is used, the whole dataset is loaded on the GPU before training begins; this may + speed up training as it avoid transfer between CPU and GPU, but it is not guaranteed to do. Note that if the + dataset is not small enough, setting this to True causes things to crash if the dataset is too large. + Default to False, you should not rely too much on this. + seed: integer, optional + Optional initial seed for the random number generator. The default value is generated randomly. + nonlinearity_simulations: torch.nn class, optional + If the neural networks for the simulations is built automatically (ie when `simulations_net` is either a + list or None), then this is used nonlinearity. Default is `torch.nn.Softplus`. This is because the Score + Matching routine (when `sliced=False`) needs the output of the simulations net to have a non-zero second + derivative with respect to data, which does not happen when using the common ReLU nonlinearity. + nonlinearity_parameters: torch.nn class, optional + If the neural networks for the simulations is built automatically (ie when `parameters_net` is either a + list or None), then this is used nonlinearity. Default is `torch.nn.ReLU`. + batch_norm: boolean, optional + If True, a batch normalization layer is put on top of the parameters net when that is built automatically. + This improves the performance of the method as it reduces the degeneracy of the + (summary statistics) * (natural parameters) product. Default is True. + batch_norm_momentum: float, optional + Momentum value with which the batch estimates in the batch norm layer are updated at each batch; see + `torch.nn.BatchNorm1d` for more information. Default is 0.1. Ignored if `batch_norm` is False, or if + an actual `parameters_net` is provided. + batch_norm_update_before_test: boolean, optional + When using batch norm layer on the test set, the resulting test loss evaluation can be noisy as the + batch norm estimates change during the train phase. To reduce this issue, it is enough to perform a simple + forward pass of the full train set (without backprop or loss evaulation) before the testing phase is + started. Set `batch_norm_update_before_test=True` to do that. Default is False. + Ignored if `batch_norm` is False, if an actual `parameters_net` is provided, as well as if no test set + is present. + lr_simulations: float, optional + The learning rate to be used in the iterative training scheme for the simulations neural network. + Default to 1e-3. + lr_parameters: float, optional + The learning rate to be used in the iterative training scheme for the parameters neural network. + Default to 1e-3. + lam: float, optional + If the full Score Matching approach is used (ie `sliced=False`) this denotes the amount of + second derivative regularization added to the Score Matching loss in the way proposed in Kingma & LeCun + (2010). Defaul is 0, corresponding to no regularization. + optimizer_simulations: torch Optimizer class, optional + A torch Optimizer class, for instance `SGD` or `Adam`, to be used for the simulations network. + Default to `Adam`. Additional parameters may be passed through the `optimizer_simulations_kwargs` argument. + optimizer_parameters: torch Optimizer class, optional + A torch Optimizer class, for instance `SGD` or `Adam`, to be used for the parameters network. + Default to `Adam`. Additional parameters may be passed through the `optimizer_parameters_kwargs` argument. + scheduler_simulations: torch _LRScheduler class, optional + A torch _LRScheduler class, used to modify the learning rate across epochs for the simulations net. + By default, a :class:`torch.optim.lr_scheduler.ExponentialLR` scheduler with `gamma=0.99` is used. + Additional arguments may be passed through the `scheduler_simulations_kwargs` parameter. + scheduler_parameters: torch _LRScheduler class, optional + A torch _LRScheduler class, used to modify the learning rate across epochs for the parameters net. + By default, a :class:`torch.optim.lr_scheduler.ExponentialLR` scheduler with `gamma=0.99` is used. + Additional arguments may be passed through the `scheduler_parameters_kwargs` parameter. + start_epoch_training: integer, optional + If schedulers is used, 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. + optimizer_simulations_kwargs: Python dictionary, optional + dictionary containing optional keyword arguments for the optimizer used for the simulations network. + optimizer_parameters_kwargs: Python dictionary, optional + dictionary containing optional keyword arguments for the optimizer used for the parameters network. + scheduler_simulations_kwargs: Python dictionary, optional + dictionary containing optional keyword arguments for the simulations scheduler. + scheduler_parameters_kwargs: Python dictionary, optional + dictionary containing optional keyword arguments for the parameters scheduler. use_tqdm : boolean, optional Whether using tqdm or not to display progress. Defaults to True. """ @@ -1154,19 +1366,19 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet if embedding_dimension is None: embedding_dimension = parameters.shape[1] - if isinstance(statistics_net, torch.nn.Module): - self.statistics_net = statistics_net + if isinstance(simulations_net, torch.nn.Module): + self.simulations_net = simulations_net self.logger.debug('We use the provided neural network for the summary statistics') - elif isinstance(statistics_net, list) or statistics_net is None: + elif isinstance(simulations_net, list) or simulations_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.statistics_net = createDefaultNNWithDerivatives( - input_size=simulations.shape[1], output_size=embedding_dimension + 1, hidden_sizes=statistics_net, - nonlinearity=torch.nn.Softplus if nonlinearity_statistics is None else nonlinearity_statistics)() + self.simulations_net = createDefaultNNWithDerivatives( + input_size=simulations.shape[1], output_size=embedding_dimension + 1, hidden_sizes=simulations_net, + nonlinearity=torch.nn.Softplus if nonlinearity_simulations is None else nonlinearity_simulations)() self.logger.debug('We generate a default neural network for the summary statistics') else: - raise RuntimeError("'statistics_net' needs to be either a torch.nn.Module, or a list, or None.") + raise RuntimeError("'simulations_net' needs to be either a torch.nn.Module, or a list, or None.") if isinstance(parameters_net, torch.nn.Module): self.parameters_net = parameters_net @@ -1184,7 +1396,7 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet raise RuntimeError("'parameters_net' needs to be either a torch.nn.Module, or a list, or None.") if cuda: - self.statistics_net.cuda() + self.simulations_net.cuda() self.parameters_net.cuda() self.logger.debug('We now run the training routine') @@ -1202,29 +1414,34 @@ def __init__(self, model, statistics_calc, backend, statistics_net=None, paramet optimizer_parameters=optimizer_parameters, scheduler_simulations=scheduler_simulations, scheduler_parameters=scheduler_parameters, - optimizer_simulations_kwargs=optimizer_simulations_kwargs, optimizer_parameters_kwargs=optimizer_parameters_kwargs, scheduler_simulations_kwargs=scheduler_simulations_kwargs, scheduler_parameters_kwargs=scheduler_parameters_kwargs, - - lam=lam, start_epoch_training=start_epoch_training, - ) + lam=lam, start_epoch_training=start_epoch_training) self.logger.info("Finished learning the transformation.") # move back the nets to CPU. - self.statistics_net.cpu() + self.simulations_net.cpu() self.parameters_net.cpu() - # todo better names overall. - def get_statistics(self, rescale_statistics=True): """ - Returns a NeuralEmbedding Statistics implementing the learned transformation. + Returns a :class:`abcpy.statistics.NeuralEmbedding` Statistics implementing the learned transformation. + + If a scaler was used, the `net` attribute of the returned object is of the class + :class:`abcpy.NN_utilities.networks.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. + + Additionally, as the learned summary statistics is given by the output of the simulations network excluding + the last component, we wrap the neural network in the :class:`abcpy.NN_utilities.networks.DiscardLastOutputNet`, + which automatically takes care of discarding the last output anytime the summary statistics are required. - 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. + Finally, notice that the summary statistics learned with the Exponential Family are only defined up to a + linear transformation. As such, it may happen that they have very different magnitude. For this reason, we + provide an option by which the summary statistics are rescale by their standard deviation on the training + (or test, whenever that was used) set. That is handled automatically by the + :class:`abcpy.statistics.NeuralEmbedding` class. Parameters ---------- @@ -1237,13 +1454,13 @@ def get_statistics(self, rescale_statistics=True): Returns ------- - abcpy.statistics.NeuralEmbedding object + :class:`abcpy.statistics.NeuralEmbedding` a statistics object that implements the learned transformation. """ if self.has_scaler_for_simulations: - net = ScalerAndNet(net=DiscardLastOutputNet(self.statistics_net), scaler=self.scaler_simulations) + net = ScalerAndNet(net=DiscardLastOutputNet(self.simulations_net), scaler=self.scaler_simulations) else: - net = DiscardLastOutputNet(self.statistics_net) + net = DiscardLastOutputNet(self.simulations_net) if rescale_statistics: # We need a hacky way here. In fact sample_statistics is the one you obtain after the first @@ -1252,8 +1469,8 @@ def get_statistics(self, rescale_statistics=True): # Then we first instantiate the NeuralEmbedding without statistics_calc, and then add it later. In this way # the standard deviation is computed correctly, but the behavior of the Statistics in new data will also be # correct. - statistics_calc_new = NeuralEmbedding(net=net, - reference_simulations=self.sample_statistics_val if self.has_val_set else self.sample_statistics) + statistics_calc_new = NeuralEmbedding(net=net, reference_simulations=self.sample_statistics_val + if self.has_val_set else self.sample_statistics) statistics_calc_new.previous_statistics = self.statistics_calc else: statistics_calc_new = NeuralEmbedding(net=net, previous_statistics=self.statistics_calc) @@ -1261,67 +1478,62 @@ def get_statistics(self, rescale_statistics=True): def get_simulations_network(self): """ - todo fix docstring - 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 the learned neural network for the simulations, representing the learned summary statistics; + if a scaler was used, the neural net is of the class + :class:`abcpy.NN_utilities.networks.ScalerAndNet`, which is a nn.Module object wrapping the scaler and the + learned neural network and automatically applies the scaler before the data is fed through the neural network. + The original neural network is contained in the `net` attribute of that. Returns ------- - abcpy.statistics.NeuralEmbedding object - a statistics object that implements the learned transformation. + torch.nn object + the learned simulations neural network """ - return ScalerAndNet(self.statistics_net, - self.scaler_simulations) if self.has_scaler_for_simulations else self.statistics_net + return ScalerAndNet(self.simulations_net, + self.scaler_simulations) if self.has_scaler_for_simulations else self.simulations_net def get_parameters_network(self): """ - todo fix docstring - 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 the learned neural network for the parameters, representing the learned natural parameters in the + exponential family; if a scaler was used, the neural net is of the class + :class:`abcpy.NN_utilities.networks.ScalerAndNet`, which is a nn.Module object wrapping the scaler and the + learned neural network and automatically applies the scaler before the data is fed through the neural network. + The original neural network is contained in the `net` attribute of that. Returns ------- - abcpy.statistics.NeuralEmbedding object - a statistics object that implements the learned transformation. + torch.nn object + the learned parameters neural network """ return ScalerAndNet(self.parameters_net, self.scaler_parameters) if self.scale_parameters else \ self.parameters_net def get_simulations_scaler(self): """ - todo fix docstring - 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 the scaler used for transforming the simulations before feeding them through the neural network. + Specifically, it can be a :class:`abcpy.transformers.BoundedVarScaler` if the simulations are transformed from + a bounded to an unbounded domain with a nonlinear transformation, or a + :class:`sklearn.preprocessing.MinMaxScaler` if the simulations were rescaled to (0,1) without non linear + transformation. It returns `None` if no scaler was used. The :class:`abcpy.transformers.BoundedVarScaler` + conforms to the same API as standard sklearn scalers, so it can be used in the same fashion. Returns ------- - abcpy.statistics.NeuralEmbedding object - a statistics object that implements the learned transformation. + abcpy.transformers.BoundedVarScaler, sklearn.preprocessing.MinMaxScaler or None + the scaler applied to simulations before the neural network (if present). """ return self.scaler_simulations if self.has_scaler_for_simulations else None def get_parameters_scaler(self): """ - todo fix docstring - 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 the scaler used for transforming the parameters before feeding them through the neural network. + It is an instance of :class:`sklearn.preprocessing.MinMaxScaler`, which rescales the parameters to (0,1). + It returns `None` if no scaler was used. Returns ------- - abcpy.statistics.NeuralEmbedding object - a statistics object that implements the learned transformation. + sklearn.preprocessing.MinMaxScaler or None + the scaler applied to parameters before the neural network (if present). """ return self.scaler_parameters if self.scale_parameters else None @@ -1338,13 +1550,13 @@ def _train(self, samples_matrix, theta_vect, optimizer_simulations_kwargs={}, optimizer_parameters_kwargs={}, scheduler_simulations_kwargs={}, scheduler_parameters_kwargs={}, start_epoch_training=0, - lam=0, use_tqdm=False): + lam=0.0, use_tqdm=False): """This assumes samples matrix to be a 2d tensor with size (n_theta, size_sample) and theta_vect a 2d tensor with size (n_theta, p). """ if self.sliced: - batch_steps = lambda samples, etas: self.single_sliced_score_matching(samples, etas, noise_type=noise_type, - variance_reduction=variance_reduction) + batch_steps = lambda samples, etas: self._single_sliced_score_matching(samples, etas, noise_type=noise_type, + variance_reduction=variance_reduction) else: batch_steps = lambda samples, etas: self._batch_Fisher_div_with_c_x(samples, etas, lam=lam) @@ -1364,10 +1576,10 @@ def _train(self, samples_matrix, theta_vect, n_theta_test = theta_vect_test.shape[0] if optimizer_simulations is None: - optimizer_simulations = Adam(self.statistics_net.parameters(), lr=lr_simulations, + optimizer_simulations = Adam(self.simulations_net.parameters(), lr=lr_simulations, **optimizer_simulations_kwargs) else: - optimizer_simulations = optimizer_simulations(self.statistics_net.parameters(), lr=lr_simulations, + optimizer_simulations = optimizer_simulations(self.simulations_net.parameters(), lr=lr_simulations, **optimizer_simulations_kwargs) if optimizer_parameters is None: @@ -1425,7 +1637,7 @@ def _train(self, samples_matrix, theta_vect, for epoch in tqdm(range(start_epoch_training, n_epochs), disable=not use_tqdm): # print("epoch", epoch) # set nets to train mode (needed as there may be a batchnorm layer there): - self.statistics_net.train() + self.simulations_net.train() self.parameters_net.train() indeces = self.rng.permutation(n_theta) # this may be a bottleneck computationally? @@ -1454,7 +1666,7 @@ def _train(self, samples_matrix, theta_vect, # set requires_grad to False to save computation if lr_simulations == 0: - set_requires_grad(self.statistics_net, False) + set_requires_grad(self.simulations_net, False) if lr_parameters == 0: set_requires_grad(self.parameters_net, False) @@ -1462,7 +1674,7 @@ def _train(self, samples_matrix, theta_vect, # reset it if lr_simulations == 0: - set_requires_grad(self.statistics_net, True) + set_requires_grad(self.simulations_net, True) if lr_parameters == 0: set_requires_grad(self.parameters_net, True) @@ -1488,7 +1700,7 @@ def _train(self, samples_matrix, theta_vect, _ = self.parameters_net(thetas_batch) batch_index += 1 - self.statistics_net.eval() + self.simulations_net.eval() self.parameters_net.eval() batch_index = 0 @@ -1517,11 +1729,11 @@ def _train(self, samples_matrix, theta_vect, if test_loss_list[-1] > test_loss_list[- 1 - epochs_test_interval]: self.logger.info("Training has been early stopped at epoch {}.".format(epoch + 1)) # reload the previous state dict: - self.statistics_net.load_state_dict(net_state_dict) + self.simulations_net.load_state_dict(net_state_dict) self.parameters_net.load_state_dict(net_state_dict_theta) break # stop training # if we did not stop: update the state dict - net_state_dict = self.statistics_net.state_dict() + net_state_dict = self.simulations_net.state_dict() net_state_dict_theta = self.parameters_net.state_dict() if enable_scheduler_simulations: @@ -1530,7 +1742,7 @@ def _train(self, samples_matrix, theta_vect, scheduler_parameters.step() # after training, return to eval mode: - self.statistics_net.eval() + self.simulations_net.eval() self.parameters_net.eval() if compute_test_loss: @@ -1540,10 +1752,10 @@ def _train(self, samples_matrix, theta_vect, def _batch_Fisher_div_with_c_x(self, samples, etas, lam=0): # do the forward pass at once here: - if hasattr(self.statistics_net, "forward_and_derivatives"): - transformed_samples, f, s = self.statistics_net.forward_and_derivatives(samples) + if hasattr(self.simulations_net, "forward_and_derivatives"): + transformed_samples, f, s = self.simulations_net.forward_and_derivatives(samples) else: - transformed_samples = self.statistics_net(samples) + transformed_samples = self.simulations_net(samples) f, s = jacobian_second_order(samples, transformed_samples, diffable=True) f = f.reshape(-1, f.shape[1], f.shape[2]) @@ -1551,18 +1763,18 @@ def _batch_Fisher_div_with_c_x(self, samples, etas, lam=0): return Fisher_divergence_loss_with_c_x(f, s, etas, lam=lam) / (samples.shape[0]) - def single_sliced_score_matching(self, samples, etas, noise=None, detach=False, noise_type='radermacher', - variance_reduction=False): - """Can either receive noise as an input or generate it. etas have been (optionally) pre-transformed by - statistics net""" - # -- THE FOLLOWING MODIFIED FROM: https://github.com/ermongroup/sliced_score_matching/blob/master/losses/sliced_sm.py -- - # these take care of generating the projection samples and computing the loss by taking the grad. - - # single_sliced_score_matching and sliced_VR_score_matching implement a basic version of SSM - # with only M=1. These are used in density estimation experiments for DKEF. - reshaped_etas = etas.view(-1, etas.shape[-1]) # THIS IS USELESS! - reshaped_etas = torch.cat((reshaped_etas, torch.ones(reshaped_etas.shape[0], 1).to(reshaped_etas)), - dim=1) # append a 1 + def _single_sliced_score_matching(self, samples, etas, noise=None, detach=False, noise_type='radermacher', + variance_reduction=False): + """Can either receive noise as an input or generate it. etas have been pre-transformed by + parameters net + This was modified from: + https://github.com/ermongroup/sliced_score_matching/blob/master/losses/sliced_sm.py + This function takes care of generating the projection samples and computing the loss by taking the grad. + + Here, only one projection is used for each sample; however the projection changes at each epoch. + """ + etas = etas.view(-1, etas.shape[-1]) + etas = torch.cat((etas, torch.ones(etas.shape[0], 1).to(etas)), dim=1) # append a 1 reshaped_samples = samples.view(-1, samples.shape[-1]) reshaped_samples.requires_grad_(True) @@ -1582,8 +1794,8 @@ def single_sliced_score_matching(self, samples, etas, noise=None, detach=False, else: vectors = noise - transformed_samples = self.statistics_net(reshaped_samples) - logp = torch.bmm(reshaped_etas.unsqueeze(1), transformed_samples.unsqueeze(2)) # way to do batch dot products + transformed_samples = self.simulations_net(reshaped_samples) + logp = torch.bmm(etas.unsqueeze(1), transformed_samples.unsqueeze(2)) # way to do batch dot products logp = logp.sum() grad1 = autograd.grad(logp, reshaped_samples, create_graph=True)[0] gradv = torch.sum(grad1 * vectors) diff --git a/abcpy/transformers.py b/abcpy/transformers.py index 89b3f5a..ef3ea6b 100644 --- a/abcpy/transformers.py +++ b/abcpy/transformers.py @@ -226,38 +226,19 @@ def jac_log_det_inverse_transform(self, x): return self._jac_log_det_inverse_transform(x) -class DummyTransformer: - """Dummy transformer which does nothing, and for which the jacobian is 1""" - - def __init__(self): - pass - - def transform(self, x): - return x - - def inverse_transform(self, x): - return x - - def jac_log_det(self, x): - return 0 - - def jac_log_det_inverse_transform(self, x): - return 0 - - class BoundedVarScaler(MinMaxScaler, BoundedVarTransformer): """ This scaler implements both lower bounded and two sided bounded transformations according to the provided bounds. After the nonlinear transformation is applied, we optionally rescale the transformed variables to the (0,1) range (default for this is True). - It works on 2d vectors. You need to specify separately the lower and upper bounds in two arrays with the same length - of the objects on which the transformations will be applied (likely the simulations used to learn the - exponential family summaries for this one). - - If the bounds for a given variable are both None, it is assumed to be unbounded; if instead the - lower bound is given and the upper bound is None, it is assumed to be lower bounded. Finally, if both bounds are - given, it is assumed to be bounded on both sides. + It works on 2d vectors. You need to specify separately the lower and upper bounds in two arrays with the same length + of the objects on which the transformations will be applied (likely the simulations used to learn the + exponential family summaries for this one). + + If the bounds for a given variable are both None, it is assumed to be unbounded; if instead the + lower bound is given and the upper bound is None, it is assumed to be lower bounded. Finally, if both bounds are + given, it is assumed to be bounded on both sides. Practically, this inherits from BoundedVarTransformer, which provides the transformations, and from sklearn MinMaxScaler, which provides the rescaling capabilities. This class has the same API as sklearn scalers, @@ -269,17 +250,17 @@ def __init__(self, lower_bound, upper_bound, feature_range=(0, 1), copy=True, re Parameters ---------- lower_bound : np.ndarray - Array of the same length of the variable to which the transformation will be applied, containing lower - bounds of the variable. Each entry of the array can be either None or a number (see above). + Array of the same length of the variable to which the transformation will be applied, containing lower + bounds of the variable. Each entry of the array can be either None or a number (see above). upper_bound - Array of the same length of the variable to which the transformation will be applied, containing upper - bounds of the variable. Each entry of the array can be either None or a number (see above). + Array of the same length of the variable to which the transformation will be applied, containing upper + bounds of the variable. Each entry of the array can be either None or a number (see above). feature_range : tuple (min, max), optional - Desired range of transformed data (obtained with the MinMaxScaler after the + Desired range of transformed data (obtained with the MinMaxScaler after the nonlinear transformation is computed). Default=(0, 1) copy : bool, optional Set to False to perform inplace row normalization and avoid a - copy in the MinMaxScaler (if the input is already a numpy array). Defaults to True. + copy in the MinMaxScaler (if the input is already a numpy array). Defaults to True. rescale_transformed_vars : bool, optional Whether to apply the MinMaxScaler after the nonlinear transformation. Defaults to True. """ @@ -290,6 +271,7 @@ def __init__(self, lower_bound, upper_bound, feature_range=(0, 1), copy=True, re @staticmethod def _check_reshape_single_sample(x): + """""" if len(x.shape) == 1: pass elif len(x.shape) == 2 and x.shape[0] == 1: @@ -300,6 +282,7 @@ def _check_reshape_single_sample(x): def fit(self, X, y=None): """Compute the minimum and maximum to be used for later scaling. + Parameters ---------- X : array-like of shape (n_samples, n_features) @@ -307,6 +290,7 @@ def fit(self, X, y=None): used for later scaling along the features axis. y : None Ignored. + Returns ------- self : object @@ -327,10 +311,12 @@ def fit(self, X, y=None): def transform(self, X): """Scale features of X according to feature_range. + Parameters ---------- X : array-like of shape (n_samples, n_features) Input data that will be transformed. + Returns ------- Xt : array-like of shape (n_samples, n_features) @@ -351,10 +337,12 @@ def transform(self, X): def inverse_transform(self, X): """Undo the scaling of X according to feature_range. + Parameters ---------- X : array-like of shape (n_samples, n_features) Input data that will be transformed. It cannot be sparse. + Returns ------- Xt : array-like of shape (n_samples, n_features) @@ -423,3 +411,22 @@ def jac_log_det_inverse_transform(self, x): x = self._check_reshape_single_sample(x) return BoundedVarTransformer._jac_log_det_inverse_transform(self, x) + + +class DummyTransformer: + """Dummy transformer which does nothing, and for which the jacobian is 1""" + + def __init__(self): + pass + + def transform(self, x): + return x + + def inverse_transform(self, x): + return x + + def jac_log_det(self, x): + return 0 + + def jac_log_det_inverse_transform(self, x): + return 0 diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py index 39aadb0..12904f6 100644 --- a/tests/statisticslearning_tests.py +++ b/tests/statisticslearning_tests.py @@ -310,7 +310,7 @@ def setUp(self): n_epochs=2, batch_norm=False, use_tqdm=False) self.statisticslearning_provide_nets = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=4, n_epochs=2, - statistics_net=createDefaultNN(3, 3)(), + simulations_net=createDefaultNN(3, 3)(), parameters_net=createDefaultNN(2, 2)(), use_tqdm=False) self.statisticslearning_embedding_dim = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, @@ -333,6 +333,9 @@ def setUp(self): n_samples=4, n_epochs=2, scheduler_parameters=False, scheduler_simulations=False, use_tqdm=False) + self.statisticslearning_lam = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, sliced=False, + lam=0.1) def test_initialization(self): if not has_torch: @@ -367,7 +370,7 @@ def test_errors(self): seed=1, parameters=np.ones((100, 1))) with self.assertRaises(RuntimeError): self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, statistics_net=createDefaultNN(1, 3)) + seed=1, simulations_net=createDefaultNN(1, 3)) with self.assertRaises(RuntimeError): self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, seed=1, parameters_net=createDefaultNN(1, 3)) From 95b351018ceb83781aac77d7b8b7e2916f23b51d Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Wed, 25 Aug 2021 18:01:16 +0100 Subject: [PATCH 28/34] Update papers --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index bc51c8d..c08edf3 100644 --- a/README.md +++ b/README.md @@ -131,9 +131,9 @@ 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.", 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.", 2020, arXiv:2006.16059. +* 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.", 2021, PLOS Computational Biology, 17(8), e1009236. -* L. Pacchiardi, P. Künzli, M. Schöngens, B. Chopard, R. Dutta, "Distance-Learning for Approximate Bayesian Computation to Model a Volcanic Eruption", 2020, Sankhya B, 1-30. +* L. Pacchiardi, P. Künzli, M. Schöngens, B. Chopard, R. Dutta, "Distance-Learning for Approximate Bayesian Computation to Model a Volcanic Eruption", 2021, Sankhya B, 83(1), 288-317. * R. Dutta, J. P. Onnela, A. Mira, "Bayesian Inference of Spreading Processes on Networks", 2018, Proceedings of Royal Society A, 474(2215), 20180129. From 11bdcf98512b28fdc42aa3f3b5a0cdaa9ebde387 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 26 Aug 2021 18:00:28 +0100 Subject: [PATCH 29/34] Better name --- abcpy/statisticslearning.py | 8 +- tests/statisticslearning_tests.py | 200 +++++++++++++++--------------- 2 files changed, 104 insertions(+), 104 deletions(-) diff --git a/abcpy/statisticslearning.py b/abcpy/statisticslearning.py index 7b4edb8..31951b1 100644 --- a/abcpy/statisticslearning.py +++ b/abcpy/statisticslearning.py @@ -1003,7 +1003,7 @@ def __init__(self, model, statistics_calc, backend, embedding_net=None, n_sample loader_kwargs=loader_kwargs) -class ExpFamStatistics(StatisticsLearningWithLosses, GraphTools): +class ExponentialFamilyScoreMatching(StatisticsLearningWithLosses, GraphTools): """This class implements the statistics learning technique using exponential family as described in Pacchiardi et al. 2020 [1]. Specifically, the idea is to fit an exponential family to a set of parameter-simulation pairs from the model, with two neural networks representing the summary statistics and the natural parameters of the @@ -1309,9 +1309,9 @@ def __init__(self, model, statistics_calc, backend, simulations_net=None, parame # this handles generation of the data (or its formatting in case the data is provided to the Semiautomatic # class) - super(ExpFamStatistics, self).__init__(model, statistics_calc, backend, n_samples, n_samples_val, - 1, parameters, simulations, seed=seed, - parameters_val=parameters_val, simulations_val=simulations_val) + super(ExponentialFamilyScoreMatching, self).__init__(model, statistics_calc, backend, n_samples, n_samples_val, + 1, 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 self.has_val_set = hasattr(self, "sample_parameters_val") and len(self.sample_parameters_val) > 0 diff --git a/tests/statisticslearning_tests.py b/tests/statisticslearning_tests.py index 12904f6..f7fe9b0 100644 --- a/tests/statisticslearning_tests.py +++ b/tests/statisticslearning_tests.py @@ -7,7 +7,7 @@ from abcpy.continuousmodels import Uniform from abcpy.statistics import Identity from abcpy.statisticslearning import Semiautomatic, SemiautomaticNN, TripletDistanceLearning, \ - ContrastiveDistanceLearning, ExpFamStatistics + ContrastiveDistanceLearning, ExponentialFamilyScoreMatching try: import torch @@ -278,7 +278,7 @@ def test_plots(self): self.statisticslearning.plot_losses(which_losses="test") -class ExpFamStatisticsTests(unittest.TestCase): +class ExponentialFamilyScoreMatchingTests(unittest.TestCase): def setUp(self): # define prior and model sigma = Uniform([[1], [2]]) @@ -292,54 +292,54 @@ def setUp(self): self.statistics_cal = Identity(degree=3, cross=False) if has_torch: - self.statisticslearning_all_defaults = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, use_tqdm=False) - self.statisticslearning_no_sliced = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, - sliced=False, use_tqdm=False) - self.statisticslearning_sphere_noise = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, use_tqdm=False, - noise_type="sphere") - self.statisticslearning_gaussian_noise = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, use_tqdm=False, - noise_type="gaussian") - self.statisticslearning_variance_reduction = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, use_tqdm=False, - variance_reduction=True) - self.statisticslearning_no_bn = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=4, - n_epochs=2, batch_norm=False, use_tqdm=False) - self.statisticslearning_provide_nets = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, - simulations_net=createDefaultNN(3, 3)(), - parameters_net=createDefaultNN(2, 2)(), - use_tqdm=False) - self.statisticslearning_embedding_dim = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, - embedding_dimension=4, use_tqdm=False) - self.statisticslearning_validation_early_stop = ExpFamStatistics([self.Y], self.statistics_cal, - self.backend, - n_samples=4, n_epochs=20, - n_samples_val=20, early_stopping=True, - use_tqdm=False) - self.statisticslearning_scale = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, scale_samples=False, - scale_parameters=True, use_tqdm=False) - self.statisticslearning_bounds = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, - lower_bound_simulations=np.array([-1000, -1000, -1000]), - upper_bound_simulations=np.array([1000, 1000, 1000]), - use_tqdm=False, seed=1) - self.statisticslearning_no_schedulers = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, - scheduler_parameters=False, - scheduler_simulations=False, use_tqdm=False) - self.statisticslearning_lam = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, - n_samples=4, n_epochs=2, use_tqdm=False, sliced=False, - lam=0.1) + self.statisticslearning_all_defaults = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False) + self.statisticslearning_no_sliced = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + sliced=False, use_tqdm=False) + self.statisticslearning_sphere_noise = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + noise_type="sphere") + self.statisticslearning_gaussian_noise = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + noise_type="gaussian") + self.statisticslearning_variance_reduction = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, + variance_reduction=True) + self.statisticslearning_no_bn = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=4, + n_epochs=2, batch_norm=False, use_tqdm=False) + self.statisticslearning_provide_nets = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + simulations_net=createDefaultNN(3, 3)(), + parameters_net=createDefaultNN(2, 2)(), + use_tqdm=False) + self.statisticslearning_embedding_dim = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + embedding_dimension=4, use_tqdm=False) + self.statisticslearning_validation_early_stop = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, + self.backend, + n_samples=4, n_epochs=20, + n_samples_val=20, early_stopping=True, + use_tqdm=False) + self.statisticslearning_scale = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, scale_samples=False, + scale_parameters=True, use_tqdm=False) + self.statisticslearning_bounds = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + lower_bound_simulations=np.array([-1000, -1000, -1000]), + upper_bound_simulations=np.array([1000, 1000, 1000]), + use_tqdm=False, seed=1) + self.statisticslearning_no_schedulers = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, + scheduler_parameters=False, + scheduler_simulations=False, use_tqdm=False) + self.statisticslearning_lam = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, + n_samples=4, n_epochs=2, use_tqdm=False, sliced=False, + lam=0.1) def test_initialization(self): if not has_torch: - self.assertRaises(ImportError, ExpFamStatistics, [self.Y], self.statistics_cal, self.backend) + self.assertRaises(ImportError, ExponentialFamilyScoreMatching, [self.Y], self.statistics_cal, self.backend) def test_transformation(self): if has_torch: @@ -366,77 +366,77 @@ def test_transformation(self): def test_errors(self): if has_torch: with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, parameters=np.ones((100, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, parameters=np.ones((100, 1))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, simulations_net=createDefaultNN(1, 3)) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, simulations_net=createDefaultNN(1, 3)) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, parameters_net=createDefaultNN(1, 3)) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, parameters_net=createDefaultNN(1, 3)) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, noise_type="ciao", use_tqdm=False) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, noise_type="ciao", use_tqdm=False) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, noise_type="sphere", variance_reduction=True, - use_tqdm=False) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, noise_type="sphere", variance_reduction=True, + use_tqdm=False) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, simulations=np.ones((100, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, simulations=np.ones((100, 1))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - simulations=np.ones((100, 1, 3))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - parameters=np.ones((100, 1, 2))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, simulations=np.ones((100, 1)), - parameters=np.zeros((99, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, simulations=np.ones((100, 1)), + parameters=np.zeros((99, 1))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - parameters_val=np.ones((100, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - simulations_val=np.ones((100, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - simulations_val=np.ones((100, 1, 3))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1, 3))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - parameters_val=np.ones((100, 1, 2))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=np.ones((100, 1, 2))) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - simulations_val=np.ones((100, 1)), - parameters_val=np.zeros((99, 1))) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + simulations_val=np.ones((100, 1)), + parameters_val=np.zeros((99, 1))) with self.assertRaises(TypeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - parameters=[i for i in range(10)], - simulations=[i for i in range(10)]) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters=[i for i in range(10)], + simulations=[i for i in range(10)]) with self.assertRaises(TypeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, - parameters_val=[i for i in range(10)], - simulations_val=[i for i in range(10)]) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, + parameters_val=[i for i in range(10)], + simulations_val=[i for i in range(10)]) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, lower_bound_simulations=[1, 2, 3]) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, lower_bound_simulations=[1, 2, 3]) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - seed=1, upper_bound_simulations=[1, 2, 3]) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + seed=1, upper_bound_simulations=[1, 2, 3]) with self.assertRaises(RuntimeError): - self.statisticslearning = ExpFamStatistics([self.Y], self.statistics_cal, self.backend, n_samples=1000, - lower_bound_simulations=np.array([-1000, -1000]), seed=1, - upper_bound_simulations=np.array([1000, 1000, 1000])) + self.statisticslearning = ExponentialFamilyScoreMatching([self.Y], self.statistics_cal, self.backend, n_samples=1000, + lower_bound_simulations=np.array([-1000, -1000]), seed=1, + upper_bound_simulations=np.array([1000, 1000, 1000])) with self.assertRaises(RuntimeError): self.statisticslearning_all_defaults.test_losses = [4, 2, 1] From 7d2d8e3de587f29c95beb2c9bceec3066041601c Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 26 Aug 2021 18:00:35 +0100 Subject: [PATCH 30/34] Update docs --- README.md | 1 + doc/source/class-diagram.png | Bin 311965 -> 318057 bytes doc/source/class-diagram.svg | 173 +++++++++++++++++++++++---------- doc/source/getting_started.rst | 16 ++- 4 files changed, 136 insertions(+), 54 deletions(-) diff --git a/README.md b/README.md index c08edf3..af126c0 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,7 @@ Additional **features** are: * several methods for summary selection: * [Semi-automatic summary selection (with Neural networks)](http://proceedings.mlr.press/v97/wiqvist19a/wiqvist19a.pdf) * [summary selection using distance learning (with Neural networks)](https://link.springer.com/article/10.1007/s13571-019-00208-8) + * [Sufficient statistics of exponential family approximating the likelihood (with Neural networks)](https://arxiv.org/abs/2012.10903) * [Random Forest Model Selection Scheme](https://academic.oup.com/bioinformatics/article/32/6/859/1744513) diff --git a/doc/source/class-diagram.png b/doc/source/class-diagram.png index 66ce1f58fbfe4c38c15e2c2b4d2271a0fa413cf1..dbdf5bd4d84f1ad726f6271737a5cfbe015880ba 100644 GIT binary patch delta 198581 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

A;i9_IJ9Hhthj+OBBlIL42re6%A42FOb->+Gzo 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

+vE2q=R@Z*M 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�!spLq9YBY=E!qR2P0eB}{*aEevCRTunAI1i^zSdFG#C zQikT}dQm3(`YOHzpd<6cNTm!fgqBW^RCUHJCwsxH3~a$TWG4ty5N#EEdwY})TOrzd z-<(c<6TuMi{Wwt{xa8^)os4bCWGaGa`r+#=5V*v4i1_$AZQ6KO3=H^PPkFc)G>%w} z4xIYB&E1fB3T?9oOycGaMR}_aYB`d`Ov2aqpfioI+VErcgw#6!gj!5jVVmc!+l#xe z*P|X#sa3mnr!HOmVz0CEZ!+<{a;$%4Z%W;pRyJ&L2?ePmaqRH+ezD1W&aa3w{>Ntj zr9mrZ&3fD}23Dw>x3}X{o4Hh@_}?c)8a#O!h{X*?tc`G6hkHj(8r%lL?N&Bh;Y&$9 z-rQm1JVrBcDb0JSP8GFYact*(>0w_fyKP?PHMyk{cxZiN+p}}0v?Kw`SJ@m67*qRN zb?T_oEAok24$ljYY2Uej|BqG|-WLhQmJFhlL+qkG>owT!1?UsC$Us!>hHkfCP|3YX z@lSX;qxddPs+AqS-}tI}rtaXr1?q(}&yQ&MJ6!FMb1ZAu0q2B}M};mX7Bs_0T*P-O zBjfvpyb*XK3BhH+fX2@7SiD^+*x~RrM^dCPwuwzj@@Fz4`YRRL3|{5PbOHx_$fhv~s@sYHRF=Y6UC`-KNCnO|@J@e1{3nCKtOWr{QoK=ZA<{Nlwm*Abt zgp@)Imj_wB!iN5F#b4W-Bmdj8L5L%LUXe%{`$yg8nf$!<&#rEA1eu7F7sUR z{}_#9;C`jWLbN&hZwGPn(n7XN$qC_v`aoU~SpD}NJZK=@t@sP^U&TTWJOZL{Q|G9t z(GA*bivWtznLr$rcaWAS?Uc^lx~W1O$7N-~8>`dJ=GE$QP!5vTKMi;GE%==5Y5)E!A1ySi&yXR_p&{U;%DRn1 z1GMo3&O0BLDgAPE;VDL)E(*#4I)_n}-)vyufG*`DZOTX9i4N_dSs|e4KwJ}}S%69R z%L|=_+zB5BPqrhO?le4ti49#9)9UI}nJ1{@q8)|w2woeL(*)8c}LdsD36qm|sIqFWVxp}+f4w2t1qRtrHL z4Di)$TT+aXC2rHb?*lVZ;pLP#3lrYGOb5jaeyI&)QW+DYN?k4>8aT>NN?g6J2~Zel z@pwS8Q(DA`-F)q~D#U1Ud=|DFPgmM`!T6!6MZcWDQ|E)%sr>h8q{`&!(*t-(FcI_AJqwQRi#57~SxlH)ienmenWdzlxQL zQ?uGWroOxf{%i;DcgwfbNeo70&MFc+?b5_SVXHOP22E;j{}=k7E3tb62-qEgzIjw? z+nPFeP}s-E=_G-hpA+x2hzMlP~ zejlIuiZj!4D1vIz)VM@Assm19_Gm;kfhhbsq zwCT1Og1PrE%2F^MvbXn4Jbd`@4xR)r6!YU&7w2%0DKcb&;a*HZhHmfPdlS~twb>TA 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%0DCT%If{}^=->u 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 x!~tr-1GhVchn3Y&dKk6$(u}N diff --git a/doc/source/class-diagram.svg b/doc/source/class-diagram.svg index 4b08208..8f0fb03 100644 --- a/doc/source/class-diagram.svg +++ b/doc/source/class-diagram.svg @@ -43,9 +43,9 @@ inkscape:window-height="1016" id="namedview2244" showgrid="false" - inkscape:zoom="2.8284271" - inkscape:cx="413.12714" - inkscape:cy="432.57257" + inkscape:zoom="1.4142136" + inkscape:cx="375.12015" + inkscape:cy="513.71308" inkscape:window-x="0" inkscape:window-y="27" inkscape:window-maximized="1" @@ -5140,7 +5140,7 @@ + transform="translate(7.8100894e-4,27.000779)"> + d="m 336.2,354.89305 -16,0.0447 0,-151.23772 h -80 v 16" + style="fill:none;stroke:#000000;stroke-width:0.4;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-opacity:1" + sodipodi:nodetypes="ccccc" /> - - - ContrastiveDistLearn SemiautomaticNN - TripletDistLearn + transform="translate(7.8100894e-4,-132.99922)"> @@ -6443,7 +6412,7 @@ clip-path="url(#clip46)" id="g4328" style="clip-rule:nonzero" - transform="translate(7.8100894e-4,-76.494221)"> + transform="translate(7.8100894e-4,-92.994221)"> + transform="translate(-10,9.5)"> + transform="translate(7.8100894e-4,-132.99922)"> + + + ExpFamScoreMatching + + + + ContrastiveDistLearn + + ContrastiveDistLearn + + + + TripletDistLearn + + TripletDistLearn + + + + diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst index 1edb5b9..c992bb3 100644 --- a/doc/source/getting_started.rst +++ b/doc/source/getting_started.rst @@ -362,11 +362,18 @@ step. The following techniques are available: * SemiautomaticNN :py:class:`abcpy.statisticslearning.SemiautomaticNN`, * ContrastiveDistanceLearning :py:class:`abcpy.statisticslearning.ContrastiveDistanceLearning`, * TripletDistanceLearning :py:class:`abcpy.statisticslearning.TripletDistanceLearning`. +* ExponentialFamilyScoreMatching :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching`. The first two build a transformation that approximates the parameter that generated the corresponding observation, the -first one by using a linear regression approach and the second one by using a neural network embedding. The other two +first one by using a linear regression approach and the second one by using a neural network embedding. The two distance +learning approaches use instead neural networks to learn an embedding of the data so that the distance between the embeddings is close to -the distance between the parameter values that generated the data. +the distance between the parameter values that generated the data. Finally, the last one fits an exponential family +approximation to the likelihood using the generated data, and uses as summary statistics the sufficient statistics of +the approximating family. Two neural networks are used here in the training phase, one to learn the summary +statistics and one to transform +the parameters to the natural parametrization of the learned exponential family (but only the second neural network will +be used when the statistics are used in inference). We remark that the techniques using neural networks require `Pytorch `_ to be installed. As this is an optional feature, however, Pytorch is not in the list of dependencies of ABCpy. Rather, when one of the neural network based routines is @@ -405,14 +412,15 @@ We remark that the minimal amount of coding needed for using the neural network :lines: 64-72 :dedent: 4 -And similarly for the other two approaches. +And similarly for the other approaches. -We remark how :py:class:`abcpy.statisticslearning.SemiautomaticNN` (as well as the other NN-based statistics learning approaches) allow to specify a neural network through the optional `embedding_net` parameter. According to the value given to it, different NNs are used: +We remark how :py:class:`abcpy.statisticslearning.SemiautomaticNN` (as well as the other NN-based statistics learning approaches) allow to specify a neural network through the optional `embedding_net` parameter (in :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching`, you analogously have `simulations_net` and `parameters_net`). According to the value given to `embedding_net`, different NNs are used: * a torch.nn object can be passed to `embedding_net` to be used as the NN to learn summary statistics. * Alternatively, a list with some integer numbers denoting the width of the hidden layers of a fully connected NN can be specified (with the length of the list corresponding to the number of hidden layers). In this case, the input and output sizes are determined so that things work correctly: input size correspond to the data size after the provided `statistics_calculator` has been applied, while output size corresponds to the number of parameters in the model. The function taking care of instantiating the NN is :py:func:`abcpy.NN_utilities.networks.createDefaultNN`. * If `embedding_net` is not specified, the behavior is similar to the latter bullet point, but with the number of hidden sizes fixed to 3 and their width determined as: ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``. +The parameters `simulations_net` and `parameters_net` of :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching` have a similar behavior, with the former network still taking as input the data after `statistics_calculator` has been applied, while the latter taking as input the parameters; additionally, here the embedding size can be chosen arbitrarily through the argument `embedding_dimension`, for which the default value is the number of parameters in the model. You can find more information in the docstring for :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching`. We can then perform the inference as before, but the distances will be computed on the newly learned summary statistics. From 9134a4d3f01ea580fcf35c7e4c45eefcc5259e0e Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 26 Aug 2021 18:19:15 +0100 Subject: [PATCH 31/34] Add example for ExpFam Statistics --- doc/source/getting_started.rst | 2 +- ..._statistics_learning_exponential_family.py | 153 ++++++++++++++++++ tests/test_examples.py | 8 + 3 files changed, 162 insertions(+), 1 deletion(-) create mode 100644 examples/statisticslearning/gaussian_statistics_learning_exponential_family.py diff --git a/doc/source/getting_started.rst b/doc/source/getting_started.rst index c992bb3..5f2ccf8 100644 --- a/doc/source/getting_started.rst +++ b/doc/source/getting_started.rst @@ -420,7 +420,7 @@ We remark how :py:class:`abcpy.statisticslearning.SemiautomaticNN` (as well as t * Alternatively, a list with some integer numbers denoting the width of the hidden layers of a fully connected NN can be specified (with the length of the list corresponding to the number of hidden layers). In this case, the input and output sizes are determined so that things work correctly: input size correspond to the data size after the provided `statistics_calculator` has been applied, while output size corresponds to the number of parameters in the model. The function taking care of instantiating the NN is :py:func:`abcpy.NN_utilities.networks.createDefaultNN`. * If `embedding_net` is not specified, the behavior is similar to the latter bullet point, but with the number of hidden sizes fixed to 3 and their width determined as: ``[int(input_size * 1.5), int(input_size * 0.75 + output_size * 3), int(output_size * 5)]``. -The parameters `simulations_net` and `parameters_net` of :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching` have a similar behavior, with the former network still taking as input the data after `statistics_calculator` has been applied, while the latter taking as input the parameters; additionally, here the embedding size can be chosen arbitrarily through the argument `embedding_dimension`, for which the default value is the number of parameters in the model. You can find more information in the docstring for :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching`. +The parameters `simulations_net` and `parameters_net` of :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching` have a similar behavior, with the former network still taking as input the data after `statistics_calculator` has been applied, while the latter taking as input the parameters; additionally, here the embedding size can be chosen arbitrarily through the argument `embedding_dimension`, for which the default value is the number of parameters in the model. You can find more information in the docstring for :py:class:`abcpy.statisticslearning.ExponentialFamilyScoreMatching`, or in the example in `examples/statisticslearning/gaussian_statistics_learning_exponential_family.py `_. We can then perform the inference as before, but the distances will be computed on the newly learned summary statistics. diff --git a/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py b/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py new file mode 100644 index 0000000..1a90573 --- /dev/null +++ b/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py @@ -0,0 +1,153 @@ +import logging + +import numpy as np + + +def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level=logging.WARN): + """Perform inference for this example. + + Parameters + ---------- + steps : integer, optional + Number of iterations in the sequential PMCABC algorithm ("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 + 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] + + # define prior + from abcpy.continuousmodels import Uniform + mu = Uniform([[150], [200]], name="mu") + sigma = Uniform([[5], [25]], name="sigma") + + # define the model + from abcpy.continuousmodels import Normal + height = Normal([mu, sigma], ) + + # 1) generate simulations from prior + from abcpy.inferences import DrawFromPrior + draw_from_prior = DrawFromPrior([height], backend=backend) + + # notice the use of the `.sample_par_sim_pairs` method rather than `.sample` to obtain data suitably formatted + # for the summary statistics learning routines + parameters, simulations = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) + # if you want to use the test loss to do early stopping in the training: + parameters_val, simulations_val = draw_from_prior.sample_par_sim_pairs(100, n_samples_per_param=1) + # discard the mid dimension (n_samples_per_param, as the StatisticsLearning classes use that =1) + simulations = simulations.reshape(simulations.shape[0], simulations.shape[2]) + simulations_val = simulations_val.reshape(simulations_val.shape[0], simulations_val.shape[2]) + + # 2) now train the NNs with the different methods with the generated data + from abcpy.statistics import Identity + identity = Identity() # to apply before computing the statistics + + logging.info("Exponential family statistics") + from abcpy.statisticslearning import ExponentialFamilyScoreMatching + exp_fam_stats = ExponentialFamilyScoreMatching( + [height], identity, backend=backend, parameters=parameters, + simulations=simulations, parameters_val=parameters_val, + simulations_val=simulations_val, + early_stopping=True, # early stopping + seed=1, n_epochs=10, batch_size=10, + scale_samples=False, # whether to rescale the samples to (0,1) before NN + scale_parameters=True, # whether to rescale the parameters to (0,1) before NN + embedding_dimension=3, # embedding dimension of both simulations and parameter networks (equal to # statistics) + sliced=True, # quicker version of score matching + ) + + # 3) save and re-load NNs: + # get the statistics from the already fit StatisticsLearning object 'exp_fam_stats'; if rescale_statistics=True, + # the training (or validation, if available) set is used to compute the standard deviation of the different + # statistics, and the statistics on each new observation/simulation are then rescaled by that. This is useful as the + # summary statistics obtained with this method can vary much in magnitude. + learned_stat = exp_fam_stats.get_statistics(rescale_statistics=True) + + # this has a save net method: + # if you used `scale_samples=True` in learning the NNs (or if the simulations were bounded, which is not the case + # here), you need to provide a path where pickle stores the scaler too: + learned_stat.save_net("exp_fam_stats.pth", path_to_scaler="scaler.pkl") + + # to reload: need to use the Neural Embedding statistics fromFile; this needs to know which kind of NN it is using; + # need therefore to pass either the input/output size (it data size and number parameters) or the network class if + # that was specified explicitly in the StatisticsLearning class. Check the docstring for NeuralEmbedding.fromFile + # for more details. + # Output size has to be here the embedding_dimension used in learning the summaries plus 1. The last component is + # a base measure which is automatically discarded when the summary statistics are used. + # Additionally, if you want to rescale the statistics by their standard deviation as discussed above, you need here + # to explicitly provide the set used for estimating the standard deviation in the argument `reference_simulations` + from abcpy.statistics import NeuralEmbedding + learned_stat_loaded = NeuralEmbedding.fromFile("exp_fam_stats.pth", input_size=1, output_size=4, + reference_simulations=simulations_val) + + # 4) perform inference + # define distance + from abcpy.distances import Euclidean + distance_calculator = Euclidean(learned_stat_loaded) + + # define kernel + from abcpy.perturbationkernel import DefaultKernel + kernel = DefaultKernel([mu, sigma]) + + # define sampling scheme + from abcpy.inferences import PMCABC + sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) + + 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], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) + + return journal + + +def analyse_journal(journal): + # output parameters and weights + print(journal.opt_values) + print(journal.get_weights()) + + # do post analysis + print(journal.posterior_mean()) + print(journal.posterior_cov()) + + # 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') + + +if __name__ == "__main__": + journal = infer_parameters(logging_level=logging.INFO) + analyse_journal(journal) diff --git a/tests/test_examples.py b/tests/test_examples.py index 6901e8d..73746aa 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -104,6 +104,14 @@ def test_gaussian_statistics_learning_DrawFromPrior_reload_NNs(self): expected_result = 172.52136853079725 self.assertAlmostEqual(test_result, expected_result) + def test_gaussian_statistics_learning_exponential_family(self): + if has_torch: + from examples.statisticslearning.gaussian_statistics_learning_exponential_family 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() From 63d7479b5347086cfb4cf51318efad5cbbe0d853 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Thu, 26 Aug 2021 18:23:16 +0100 Subject: [PATCH 32/34] Remove tqdm from examples --- .../gaussian_statistics_learning_DrawFromPrior_reload_NNs.py | 4 ++-- .../gaussian_statistics_learning_exponential_family.py | 5 +++-- .../pmcabc_gaussian_statistics_learning.py | 2 +- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py index 03cd19b..3363ade 100644 --- a/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py +++ b/examples/statisticslearning/gaussian_statistics_learning_DrawFromPrior_reload_NNs.py @@ -71,13 +71,13 @@ def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level= semiNN = SemiautomaticNN([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations_val, early_stopping=True, # early stopping - seed=1, n_epochs=10, scale_samples=False) + seed=1, n_epochs=10, scale_samples=False, use_tqdm=False) logging.info("triplet") triplet = TripletDistanceLearning([height], identity, backend=backend, parameters=parameters, simulations=simulations, parameters_val=parameters_val, simulations_val=simulations_val, early_stopping=True, # early stopping - seed=1, n_epochs=10, scale_samples=True) + seed=1, n_epochs=10, scale_samples=True, use_tqdm=False) # 3) save and re-load NNs: # get the statistics from the already fit StatisticsLearning object 'semiNN': diff --git a/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py b/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py index 1a90573..c722589 100644 --- a/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py +++ b/examples/statisticslearning/gaussian_statistics_learning_exponential_family.py @@ -76,8 +76,9 @@ def infer_parameters(steps=2, n_sample=50, n_samples_per_param=1, logging_level= seed=1, n_epochs=10, batch_size=10, scale_samples=False, # whether to rescale the samples to (0,1) before NN scale_parameters=True, # whether to rescale the parameters to (0,1) before NN - embedding_dimension=3, # embedding dimension of both simulations and parameter networks (equal to # statistics) - sliced=True, # quicker version of score matching + embedding_dimension=3, # embedding dimension of both simulations and parameter networks (equal to # statistics) + sliced=True, # quicker version of score matching + use_tqdm=False # do not use tqdm to display progress ) # 3) save and re-load NNs: diff --git a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py index 387f720..abbcc29 100644 --- a/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py +++ b/examples/statisticslearning/pmcabc_gaussian_statistics_learning.py @@ -65,7 +65,7 @@ def infer_parameters(steps=3, n_sample=250, n_samples_per_param=10, logging_leve # 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_val=200, + n_samples=1000, n_samples_val=200, n_epochs=20, use_tqdm=False, n_samples_per_param=1, seed=1, early_stopping=True) # Redefine the statistics function From f0ac8a9502b77330ef1d09372ff227cac653fa67 Mon Sep 17 00:00:00 2001 From: Lorenzo Pacchiardi Date: Fri, 27 Aug 2021 15:06:03 +0100 Subject: [PATCH 33/34] Fix in Wasserstein distance diagnostic check --- abcpy/output.py | 9 +++++---- tests/output_tests.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 4 deletions(-) diff --git a/abcpy/output.py b/abcpy/output.py index ad189dd..a2f8ccc 100644 --- a/abcpy/output.py +++ b/abcpy/output.py @@ -918,17 +918,18 @@ def Wass_convergence_plot(self, num_iter_max=1e8, **kwargs): "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": + last_params = np.array(self.get_accepted_parameters()) + if last_params.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" + "dimensions (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): - params_1 = self.get_accepted_parameters(i) - params_2 = self.get_accepted_parameters(i + 1) + params_1 = np.array(self.get_accepted_parameters(i)) + params_2 = np.array(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 diff --git a/tests/output_tests.py b/tests/output_tests.py index 6e2547e..347cad3 100644 --- a/tests/output_tests.py +++ b/tests/output_tests.py @@ -171,6 +171,41 @@ def test_plot_wass_dist(self): print(len(journal_4.accepted_parameters)) self.assertRaises(RuntimeError, journal_4.Wass_convergence_plot) + # now use lists + weights_identical = np.ones((100, 1)) + params_0 = params_0.tolist() + weights_1 = np.arange(100) + params_1 = params_1.tolist() + weights_2 = np.arange(100, 200) + params_2 = params_2.tolist() + weights_3 = np.arange(200, 300) + params_3 = params_3.tolist() + weights_4 = np.arange(300, 400) + params_4 = params_4.tolist() + 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.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_3.Wass_convergence_plot) + journal_4 = Journal(1) + journal_4.add_accepted_parameters(np.array([np.array([1]), np.array([1, 2])], dtype="object")) + 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) weights_identical = np.ones((100, 1)) From a3cdcf59915956e5d6854da98f1536fcac21efdc Mon Sep 17 00:00:00 2001 From: Ritabrata Dutta Date: Fri, 27 Aug 2021 23:19:20 +0100 Subject: [PATCH 34/34] Update VERSION --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index b616048..844f6a9 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.6.2 +0.6.3