From 851d502b691fd342c5601e7d5b75d09cb8683581 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Sun, 12 Jan 2020 01:16:15 +0100 Subject: [PATCH 01/11] effectively allow abc.load with r data (#242) * effectively allow abc.load with r data * fix kde matrix subplot title --- doc/examples/resuming.ipynb | 36 ++++++++++++++++++------------------ pyabc/external/r_rpy2.py | 16 ++++++++-------- pyabc/visualization/kde.py | 2 +- test/test_external.py | 15 ++++++++++++--- 4 files changed, 39 insertions(+), 30 deletions(-) diff --git a/doc/examples/resuming.ipynb b/doc/examples/resuming.ipynb index a4674b2d5..cb41809b5 100644 --- a/doc/examples/resuming.ipynb +++ b/doc/examples/resuming.ipynb @@ -54,7 +54,7 @@ "outputs": [], "source": [ "from pyabc import ABCSMC, Distribution, RV\n", - "import scipy as sp\n", + "import numpy as np\n", "from tempfile import gettempdir\n", "import os" ] @@ -76,7 +76,7 @@ "outputs": [], "source": [ "def model(parameter):\n", - " return {\"data\": parameter[\"mean\"] + sp.randn()}\n", + " return {\"data\": parameter[\"mean\"] + np.random.randn()}\n", "\n", "prior = Distribution(mean=RV(\"uniform\", 0, 5))\n", "\n", @@ -105,14 +105,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:History:Start \n" + "INFO:History:Start \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Run ID: 44\n" + "Run ID: 1\n" ] } ], @@ -143,14 +143,14 @@ "output_type": "stream", "text": [ "INFO:ABC:Calibration sample before t=0.\n", - "INFO:Epsilon:initial epsilon is 1.2912959543955556\n", - "INFO:ABC:t: 0, eps: 1.2912959543955556.\n", - "INFO:ABC:Acceptance rate: 100 / 224 = 4.4643e-01.\n", - "INFO:ABC:t: 1, eps: 0.6651774908568672.\n", - "INFO:ABC:Acceptance rate: 100 / 326 = 3.0675e-01.\n", - "INFO:ABC:t: 2, eps: 0.33355947653050755.\n", - "INFO:ABC:Acceptance rate: 100 / 572 = 1.7483e-01.\n", - "INFO:History:Done \n" + "INFO:Epsilon:initial epsilon is 1.281948779424301\n", + "INFO:ABC:t: 0, eps: 1.281948779424301.\n", + "INFO:ABC:Acceptance rate: 100 / 193 = 5.1813e-01, ESS=1.0000e+02.\n", + "INFO:ABC:t: 1, eps: 0.593462311078578.\n", + "INFO:ABC:Acceptance rate: 100 / 338 = 2.9586e-01, ESS=8.2825e+01.\n", + "INFO:ABC:t: 2, eps: 0.3285232421992942.\n", + "INFO:ABC:Acceptance rate: 100 / 506 = 1.9763e-01, ESS=7.8478e+01.\n", + "INFO:History:Done \n" ] } ], @@ -241,7 +241,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -262,16 +262,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:Epsilon:initial epsilon is 0.1529406275096243\n", - "INFO:ABC:t: 3, eps: 0.1529406275096243.\n", - "INFO:ABC:Acceptance rate: 100 / 1197 = 8.3542e-02.\n", - "INFO:History:Done \n" + "INFO:Epsilon:initial epsilon is 0.19946300333077085\n", + "INFO:ABC:t: 3, eps: 0.19946300333077085.\n", + "INFO:ABC:Acceptance rate: 100 / 931 = 1.0741e-01, ESS=9.0195e+01.\n", + "INFO:History:Done \n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, diff --git a/pyabc/external/r_rpy2.py b/pyabc/external/r_rpy2.py index bd2b47446..4440ef048 100644 --- a/pyabc/external/r_rpy2.py +++ b/pyabc/external/r_rpy2.py @@ -19,14 +19,14 @@ from ..random_variables import Parameter import numpy as np import pandas as pd -import numbers import warnings import logging logger = logging.getLogger("External") try: - from rpy2.robjects import ListVector, r + from rpy2.robjects import (ListVector, r, default_converter, conversion, + pandas2ri, numpy2ri) except ImportError: # in Python 3.6 ModuleNotFoundError can be used logger.error( "Install rpy2 to enable simple support for the R language.") @@ -40,12 +40,12 @@ def dict_to_named_list(dct): or isinstance(dct, Parameter) or isinstance(dct, pd.core.series.Series)): dct = {key: val for key, val in dct.items()} - # convert numbers to builtin types before conversion (see rpy2 #548) - for key, val in dct.items(): - if isinstance(val, numbers.Integral): - dct[key] = int(val) - elif isinstance(val, numbers.Number): - dct[key] = float(val) + # convert numbers, numpy arrays and pandas dataframes to builtin + # types before conversion (see rpy2 #548) + with conversion.localconverter( + default_converter + pandas2ri.converter + numpy2ri.converter): + for key, val in dct.items(): + dct[key] = conversion.py2rpy(val) r_list = ListVector(dct) return r_list return dct diff --git a/pyabc/visualization/kde.py b/pyabc/visualization/kde.py index 9010b62ea..cbd36037d 100644 --- a/pyabc/visualization/kde.py +++ b/pyabc/visualization/kde.py @@ -452,7 +452,7 @@ def hist_2d(x, y, ax): ymin=limits.get(y.name, default)[0], ymax=limits.get(y.name, default)[1], numx=numx, numy=numy, - ax=ax, title=False, colorbar=colorbar, + ax=ax, title=None, colorbar=colorbar, refval=refval, refval_color=refval_color, kde=kde) diff --git a/test/test_external.py b/test/test_external.py index a399507cb..6522389ea 100644 --- a/test/test_external.py +++ b/test/test_external.py @@ -36,17 +36,26 @@ def test_rpy2(sampler): model = r.model("myModel") distance = r.distance("myDistance") sum_stat = r.summary_statistics("mySummaryStatistics") + data = r.observation("mySumStatData") prior = pyabc.Distribution(meanX=pyabc.RV("uniform", 0, 10), meanY=pyabc.RV("uniform", 0, 10)) abc = pyabc.ABCSMC(model, prior, distance, summary_statistics=sum_stat, - sampler=sampler, - population_size=3) + sampler=sampler, population_size=5) db = pyabc.create_sqlite_db_id(file_="test_external.db") - abc.new(db, r.observation("mySumStatData")) + abc.new(db, data) history = abc.run(minimum_epsilon=0.9, max_nr_populations=2) history.get_weighted_sum_stats_for_model(m=0, t=1)[1][0]["cars"].head() + # try load + id_ = history.id + abc = pyabc.ABCSMC(model, prior, distance, + summary_statistics=sum_stat, + sampler=sampler, population_size=6) + # shan't even need to pass the observed data again + abc.load(db, id_) + abc.run(minimum_epsilon=0.1, max_nr_populations=2) + def test_rpy2_details(): # check using a py model and an r sumstat From b92941ebd9b7b53e86b5ca25144848542adc76b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Tue, 14 Jan 2020 12:37:48 +0100 Subject: [PATCH 02/11] Resample (#244) * add resampling from weighted particles * add deterministic resampling * fix unneeded variable --- pyabc/weighted_statistics.py | 77 ++++++++++++++++++++++++++++++++ test/test_weighted_statistics.py | 54 +++++++++++++++++++++- 2 files changed, 130 insertions(+), 1 deletion(-) diff --git a/pyabc/weighted_statistics.py b/pyabc/weighted_statistics.py index 8d629cff6..8036fcdf1 100644 --- a/pyabc/weighted_statistics.py +++ b/pyabc/weighted_statistics.py @@ -81,3 +81,80 @@ def effective_sample_size(weights): weights = np.array(weights) n_eff = np.sum(weights)**2 / np.sum(weights**2) return n_eff + + +def resample(points, weights, n): + """ + Resample from weighted samples. + + Parameters + ---------- + points: + The random samples. + weights: + Weights of each sample point. + n: + Number of samples to resample. + + Returns + ------- + resampled: + A total of `n` points sampled from `points` with putting back + according to `weights`. + """ + weights = np.array(weights) + weights /= np.sum(weights) + resampled = np.random.choice(points, size=n, p=weights) + return resampled + + +def resample_deterministic(points, weights, n, enforce_n=False): + """ + Resample from weighted samples in a deterministic manner. Essentially, + multiplicities are picked as follows: + The weights are multiplied by the target number `n` and rounded to the + nearest integer, potentially with correction if `enforce_n`. + + Parameters + ---------- + points: + The random samples. + weights: + Weights of each sample point. + n: + Number of samples to resample. + enforce_n: + Whether to enforce the returned array to have length `n`. + If not, its length can be slightly off, but it may be more + representative. + + Returns + ------- + resampled: + A total of (roughly) `n` points resampled from `points` + deterministically using a rational representation of the `weights`. + """ + weights = np.array(weights) + numbers_f = weights * (n / np.sum(weights)) + + numbers = np.round(numbers_f) + + # enforce return array length + if enforce_n and np.sum(numbers) != n: + residuals = numbers_f - numbers + # sort the residuals mon. inc. + order = np.argsort(residuals) + # increment numbers with largest offsets + while np.sum(numbers) < n: + numbers[order[-1]] += 1 + order = order[:-1] + # decrement numbers with largest negative offsets + while np.sum(numbers) > n: + numbers[order[0]] -= 1 + order = order[1:] + + resampled = [] + for i, ni in enumerate(numbers): + resampled.extend([points[i]] * int(ni)) + + return resampled diff --git a/test/test_weighted_statistics.py b/test/test_weighted_statistics.py index 8e93e2404..2a46a9493 100644 --- a/test/test_weighted_statistics.py +++ b/test/test_weighted_statistics.py @@ -1,5 +1,5 @@ import numpy as np - +from scipy.stats import ks_2samp import pyabc.weighted_statistics as ws @@ -37,3 +37,55 @@ def test_weighted_std(): std_ = np.sqrt(np.sum(weights * (points - m_)**2)) assert std == std_ + + +def test_resample(): + """ + Test that the resampling process yields consistent distributions, + using a KS test. + """ + nw = 50 # number of weighted points + points = np.random.randn(nw) + weights = np.random.rand(nw) + weights /= np.sum(weights) + + n = 1000 # number of non-weighted points + # sample twice from same samples + resampled1 = ws.resample(points, weights, n) + resampled2 = ws.resample(points, weights, n) + + # should be same distribution + _, p = ks_2samp(resampled1, resampled2) + assert p > 1e-2 + + # use different points + points3 = np.random.randn(nw) + resampled3 = ws.resample(points3, weights, n) + # should be different distributions + _, p = ks_2samp(resampled1, resampled3) + assert p < 1e-2 + + +def test_resample_deterministic(): + """ + Test the deterministic resampling routine. + """ + nw = 50 # number of weighed points + points = np.random.randn(nw) + weights = np.random.rand(nw) + weights /= np.sum(weights) + + n = 1000 # number of non-weighted points + resampled_det = ws.resample_deterministic(points, weights, n, False) + + resampled = ws.resample(points, weights, n) + + # should be same distribution + _, p = ks_2samp(resampled_det, resampled) + assert p > 1e-2 + + resampled_det2 = ws.resample_deterministic(points, weights, n, True) + assert len(resampled_det2) == n + + _, p = ks_2samp(resampled_det2, resampled) + assert p > 1e-2 From ee782cffb87a91223bec9fc7fdb78c580e7be358 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Tue, 14 Jan 2020 12:38:46 +0100 Subject: [PATCH 03/11] Feature relative ess (#245) * add option to show relative ESSs * rerun parameter_inference nb due to scipy deprecation --- doc/examples/parameter_inference.ipynb | 37 ++++++++++---------- pyabc/visualization/effective_sample_size.py | 6 ++++ test/visualization/test_visualization.py | 2 +- 3 files changed, 26 insertions(+), 19 deletions(-) diff --git a/doc/examples/parameter_inference.ipynb b/doc/examples/parameter_inference.ipynb index 42346ac42..db244ed51 100644 --- a/doc/examples/parameter_inference.ipynb +++ b/doc/examples/parameter_inference.ipynb @@ -51,7 +51,7 @@ "source": [ "import pyabc\n", "\n", - "import scipy as sp\n", + "import numpy as np\n", "import scipy.stats as st\n", "import tempfile\n", "import os\n", @@ -77,7 +77,7 @@ "outputs": [], "source": [ "def model(parameter):\n", - " return {\"data\": parameter[\"mean\"] + 0.5 * sp.randn()}" + " return {\"data\": parameter[\"mean\"] + 0.5 * np.random.randn()}" ] }, { @@ -173,13 +173,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:History:Start \n" + "INFO:History:Start \n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -219,18 +219,19 @@ "output_type": "stream", "text": [ "INFO:ABC:Calibration sample before t=0.\n", - "INFO:Epsilon:initial epsilon is 1.1849960610510493\n", - "INFO:ABC:t: 0, eps: 1.1849960610510493.\n", - "INFO:ABC:Acceptance rate: 100 / 232 = 4.3103e-01, ESS=1.0000e+02.\n", - "INFO:ABC:t: 1, eps: 0.5476201652862094.\n", - "INFO:ABC:Acceptance rate: 100 / 231 = 4.3290e-01, ESS=9.5762e+01.\n", - "INFO:ABC:t: 2, eps: 0.2718593623820384.\n", - "INFO:ABC:Acceptance rate: 100 / 418 = 2.3923e-01, ESS=8.5197e+01.\n", - "INFO:ABC:t: 3, eps: 0.13719057598422357.\n", - "INFO:ABC:Acceptance rate: 100 / 764 = 1.3089e-01, ESS=9.3054e+01.\n", - "INFO:ABC:t: 4, eps: 0.0800249948630974.\n", - "INFO:ABC:Acceptance rate: 100 / 1082 = 9.2421e-02, ESS=7.9171e+01.\n", - "INFO:History:Done \n" + "INFO:Epsilon:initial epsilon is 1.319732537446763\n", + "INFO:ABC:t: 0, eps: 1.319732537446763.\n", + "INFO:ABC:Acceptance rate: 100 / 183 = 5.4645e-01, ESS=1.0000e+02.\n", + "INFO:ABC:t: 1, eps: 0.6266780218276696.\n", + "INFO:ABC:Acceptance rate: 100 / 212 = 4.7170e-01, ESS=9.5391e+01.\n", + "INFO:ABC:t: 2, eps: 0.37028667452653585.\n", + "INFO:ABC:Acceptance rate: 100 / 293 = 3.4130e-01, ESS=7.0363e+01.\n", + "INFO:ABC:t: 3, eps: 0.14892234681938504.\n", + "INFO:ABC:Acceptance rate: 100 / 713 = 1.4025e-01, ESS=7.6078e+01.\n", + "INFO:ABC:t: 4, eps: 0.07515483935316057.\n", + "INFO:ABC:Acceptance rate: 100 / 1255 = 7.9681e-02, ESS=9.2198e+01.\n", + "INFO:ABC:Stopping: minimum epsilon.\n", + "INFO:History:Done \n" ] } ], @@ -286,7 +287,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -324,7 +325,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/pyabc/visualization/effective_sample_size.py b/pyabc/visualization/effective_sample_size.py index d5d4e8988..eaf9cfd4b 100644 --- a/pyabc/visualization/effective_sample_size.py +++ b/pyabc/visualization/effective_sample_size.py @@ -13,6 +13,7 @@ def plot_effective_sample_sizes( labels: Union[List, str] = None, rotation: int = 0, title: str = "Effective sample size", + relative: bool = False, colors: List = None, size: tuple = None, ax: mpl.axes.Axes = None): @@ -32,6 +33,9 @@ def plot_effective_sample_sizes( a tilting of 45 or even 90 can be preferable. title: str, optional (default = "Total required samples") Title for the plot. + relative: bool, optional (default = False) + Whether to show relative sizes (to 1) or w.r.t. the real number + of particles. colors: List, optional Colors to use for the lines. If None, then the matplotlib default values are used. @@ -64,6 +68,8 @@ def plot_effective_sample_sizes( # we need the weights not normalized to 1 for each model w = history.get_weighted_distances(t=t)['w'] ess = effective_sample_size(w) + if relative: + ess /= len(w) esss.append(ess) essss.append(esss) diff --git a/test/visualization/test_visualization.py b/test/visualization/test_visualization.py index 160159183..f716cbce4 100644 --- a/test/visualization/test_visualization.py +++ b/test/visualization/test_visualization.py @@ -90,7 +90,7 @@ def test_total_sample_numbers(): def test_effective_sample_sizes(): pyabc.visualization.plot_effective_sample_sizes( - histories, labels, rotation=45) + histories, labels, rotation=45, relative=True) plt.close() From ec174f3c5693b9d27cbbe55d2a9ae63790a34288 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Tue, 14 Jan 2020 12:43:38 +0100 Subject: [PATCH 04/11] Feature listtemp (#248) * add ListTemperature, TemperatureBase * fix temperature base class usage --- pyabc/__init__.py | 4 ++++ pyabc/epsilon/__init__.py | 4 ++++ pyabc/epsilon/temperature.py | 33 ++++++++++++++++++++++++++++++++- pyabc/smc.py | 9 +++++---- test/test_epsilon.py | 9 +++++++++ 5 files changed, 54 insertions(+), 5 deletions(-) diff --git a/pyabc/__init__.py b/pyabc/__init__.py index 66155b82e..688e94903 100644 --- a/pyabc/__init__.py +++ b/pyabc/__init__.py @@ -46,6 +46,8 @@ QuantileEpsilon, MedianEpsilon, ListEpsilon, + TemperatureBase, + ListTemperature, Temperature, TemperatureScheme, AcceptanceRateScheme, @@ -117,6 +119,8 @@ "ListEpsilon", "QuantileEpsilon", "MedianEpsilon", + "TemperatureBase", + "ListTemperature", "Temperature", "TemperatureScheme", "AcceptanceRateScheme", diff --git a/pyabc/epsilon/__init__.py b/pyabc/epsilon/__init__.py index f77153ba7..d50d366f3 100644 --- a/pyabc/epsilon/__init__.py +++ b/pyabc/epsilon/__init__.py @@ -19,6 +19,8 @@ MedianEpsilon, ) from .temperature import ( + TemperatureBase, + ListTemperature, Temperature, TemperatureScheme, AcceptanceRateScheme, @@ -41,6 +43,8 @@ 'QuantileEpsilon', 'MedianEpsilon', # temperature + 'TemperatureBase', + 'ListTemperature', 'Temperature', 'TemperatureScheme', 'AcceptanceRateScheme', diff --git a/pyabc/epsilon/temperature.py b/pyabc/epsilon/temperature.py index b29d28d91..f71b78508 100644 --- a/pyabc/epsilon/temperature.py +++ b/pyabc/epsilon/temperature.py @@ -13,11 +13,42 @@ logger = logging.getLogger("Epsilon") -class Temperature(Epsilon): +class TemperatureBase(Epsilon): """ A temperature scheme handles the decrease of the temperatures employed by a :class:`pyabc.acceptor.StochasticAcceptor` over time. + This class is not functional on its own, its derivatives must be used. + """ + + +class ListTemperature(TemperatureBase): + """ + Pass a list of temperature values to use successively. + + Parameters + ---------- + values: + The array of temperatures to use successively. + For exact inference, finish with 1. + """ + + def __init__(self, values: List[float]): + self.values = values + + def __call__(self, + t: int) -> float: + return self.values[t] + + +class Temperature(TemperatureBase): + """ + This class implements a highly adaptive and configurable temperature + scheme. Via the argument `schemes`, arbitrary temperature schemes can be + passed to calculate the next generation's temperature, via `aggregate_fun` + one can define how to combine multiple guesses, via `initial_temperature` + the initial temperature can be set. + Parameters ---------- schemes: Union[Callable, List[Callable]], optional diff --git a/pyabc/smc.py b/pyabc/smc.py index 4a35854a6..e381262b4 100644 --- a/pyabc/smc.py +++ b/pyabc/smc.py @@ -18,7 +18,7 @@ from .acceptor import (Acceptor, UniformAcceptor, SimpleFunctionAcceptor, StochasticAcceptor) from .distance import Distance, PNormDistance, to_distance, StochasticKernel -from .epsilon import Epsilon, MedianEpsilon, Temperature +from .epsilon import Epsilon, MedianEpsilon, TemperatureBase from .model import Model, SimpleModel from .platform_factory import DefaultSampler from .population import Particle, Population @@ -229,13 +229,14 @@ def __init__(self, def _sanity_check(self): # check stochastic setting stochastics = [isinstance(self.acceptor, StochasticAcceptor), - isinstance(self.eps, Temperature), + isinstance(self.eps, TemperatureBase), isinstance(self.distance_function, StochasticKernel)] # check if usage is consistent if not all(stochastics) and any(stochastics): raise ValueError( "Please only use acceptor.StochasticAcceptor, " - "epsilon.Temperature and distance.StochasticKernel together.") + "epsilon.TemperatureBase and distance.StochasticKernel " + "together.") def __getstate__(self): state_red_dict = self.__dict__.copy() @@ -838,7 +839,7 @@ def run(self, """ # handle arguments if minimum_epsilon is None: - if isinstance(self.eps, Temperature): + if isinstance(self.eps, TemperatureBase): minimum_epsilon = 1.0 else: minimum_epsilon = 0.0 diff --git a/test/test_epsilon.py b/test/test_epsilon.py index 1d47580aa..a48ccac27 100644 --- a/test/test_epsilon.py +++ b/test/test_epsilon.py @@ -53,6 +53,15 @@ def test_medianepsilon(): assert np.isclose(eps.alpha, 0.5) +def test_listtemperature(): + eps = pyabc.ListTemperature(values=[10, 5, 1.5]) + + # might be useful to test integration, but for the moment + # standalone tests may suffice + assert eps(0) == 10 + assert eps(2) == 1.5 + + def test_temperature(): acceptor_config = { 'pdf_norm': 5, From 9be9ce6c9ef7b948a26083a9f33469c87a027548 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Tue, 14 Jan 2020 13:10:17 +0100 Subject: [PATCH 05/11] make samples available globally in __init__ (#249) --- pyabc/__init__.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/pyabc/__init__.py b/pyabc/__init__.py index 688e94903..4fa354a3e 100644 --- a/pyabc/__init__.py +++ b/pyabc/__init__.py @@ -57,6 +57,14 @@ DalyScheme, FrielPettittScheme, EssScheme) +from .sampler import ( + SingleCoreSampler, + MulticoreParticleParallelSampler, + MappingSampler, + DaskDistributedSampler, + RedisEvalParallelSampler, + MulticoreEvalParallelSampler, + ConcurrentFutureSampler) from .smc import ABCSMC from .storage import ( History, @@ -89,6 +97,7 @@ __all__ = [ + # smc "ABCSMC", # distance "Distance", @@ -130,6 +139,14 @@ "DalyScheme", "FrielPettittScheme", "EssScheme", + # sampler + "SingleCoreSampler", + "MulticoreParticleParallelSampler", + "MappingSampler", + "DaskDistributedSampler", + "RedisEvalParallelSampler", + "MulticoreEvalParallelSampler", + "ConcurrentFutureSampler", # random variable "RVBase", "RV", @@ -162,7 +179,7 @@ "Model", "SimpleModel", "IntegratedModel", - # history + # storage "History", "create_sqlite_db_id", # visualization From d0b0e675df817b7758bcae215c2b9bee4510356c Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Tue, 14 Jan 2020 13:13:33 +0100 Subject: [PATCH 06/11] update releasenotes --- doc/releasenotes.rst | 9 +++++++++ pyabc/version.py | 2 +- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index 2b6f0deda..6a5bd843f 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -8,6 +8,15 @@ Release Notes .......... +0.9.26 (2020-01-14) +------------------- + +* Make samplers available in global namespace (#249). +* Implement ListTemperature (#248). +* Allow plotting the relative ESS (#245). +* Allow resampling of weighted particles (#244). + + 0.9.25 (2020-01-08) ------------------- diff --git a/pyabc/version.py b/pyabc/version.py index e6aef0d02..fbf8d12ff 100644 --- a/pyabc/version.py +++ b/pyabc/version.py @@ -1 +1 @@ -__version__ = "0.9.25" +__version__ = "0.9.26" From 309b4b40ae6bb8a59fb34fe23743773d566c421b Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Wed, 15 Jan 2020 15:07:15 +0100 Subject: [PATCH 07/11] fix docs --- doc/releasenotes.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index 6a5bd843f..dbc35c621 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -8,13 +8,14 @@ Release Notes .......... -0.9.26 (2020-01-14) +0.9.26 (2020-01-15) ------------------- * Make samplers available in global namespace (#249). * Implement ListTemperature (#248). * Allow plotting the relative ESS (#245). * Allow resampling of weighted particles (#244). +* Fix ABCSMC.load with rpy2 (#242). 0.9.25 (2020-01-08) From 9d5b13dab1db858eb5579d50d4defdf0e9278fd7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Fri, 24 Jan 2020 23:26:31 +0100 Subject: [PATCH 08/11] Various fixes (#257) * clean up dict_to/from_json functions; add test; fix scipy deprec * fix docstring typos * add possibility to check existence of db; fixes #253 * set ylim to <= 0; fixes #254 * update releasenotes * fix further scipy deprecations * more scipy * fix docstring style * update releasenotes * clean up history args * use correct assert terminology --- doc/releasenotes.rst | 5 +- pyabc/storage/history.py | 40 ++++++++-- pyabc/storage/json.py | 32 ++++++-- pyabc/visualization/data.py | 10 +-- pyabc/visualization/kde.py | 1 + test/test_populationstrategy.py | 34 ++++----- test/test_resume_run.py | 4 +- test/test_samplers.py | 5 +- test/test_stop_sampling.py | 4 +- test/test_storage.py | 44 ++++++++--- .../test_abc_smc_algorithm.py | 74 +++++++++---------- test_performance/test_samplerperf.py | 4 +- 12 files changed, 163 insertions(+), 94 deletions(-) diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index dbc35c621..fc1cd23b1 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -8,9 +8,12 @@ Release Notes .......... -0.9.26 (2020-01-15) +0.9.26 (2020-01-24) ------------------- +* Add optional check whether database is non-existent, to detect typos. +* Set lower bound in 1-dim KDEs to <= 0 to not wrongly display near-uniform + distributions. (both #257) * Make samplers available in global namespace (#249). * Implement ListTemperature (#248). * Allow plotting the relative ESS (#245). diff --git a/pyabc/storage/history.py b/pyabc/storage/history.py index 36c2a71e2..14ac8cc7d 100644 --- a/pyabc/storage/history.py +++ b/pyabc/storage/history.py @@ -83,6 +83,24 @@ def create_sqlite_db_id( return "sqlite:///" + os.path.join(dir_, file_) +def assert_db_exists(db: str): + """ + Check if db exists. If it is a file and does not exist, raise + an error. This is helpful to avoid misspelling a file name and + then working with an empty history. + + Parameters + ---------- + db: + As passed to History. + """ + if not db.startswith("sqlite:///"): + return + file_ = db[10:] + if not os.path.exists(file_): + raise ValueError(f"Database file {db} does not exist.") + + class History: """ History for ABCSMC. @@ -93,7 +111,7 @@ class History: Attributes ---------- - db_identifier: str + db: str SQLalchemy database identifier. For a relative path use the template "sqlite:///file.db", for an absolute path "sqlite:////path/to/file.db", and for an in-memory database @@ -116,11 +134,23 @@ class History: # time before first population time PRE_TIME = -1 - def __init__(self, db: str, stores_sum_stats: bool = True, _id=None): + def __init__(self, + db: str, + stores_sum_stats: bool = True, + _id: int = None, + create: bool = True): """ Initialize history object. + + Parameters + ---------- + create: + If False, an error is thrown if the database does not exist. """ - self.db_identifier = db + if not create: + assert_db_exists(db) + + self.db = db self.stores_sum_stats = stores_sum_stats # to be filled using the session wrappers @@ -133,7 +163,7 @@ def __init__(self, db: str, stores_sum_stats: bool = True, _id=None): self._id = _id def db_file(self): - f = self.db_identifier.split(":")[-1][3:] + f = self.db.split(":")[-1][3:] return f @property @@ -541,7 +571,7 @@ def _make_session(self): # but I'm not quite sure anymore from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker - engine = create_engine(self.db_identifier, + engine = create_engine(self.db, connect_args={'timeout': self.DB_TIMEOUT}) Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) diff --git a/pyabc/storage/json.py b/pyabc/storage/json.py index 14e6da883..de385efb9 100644 --- a/pyabc/storage/json.py +++ b/pyabc/storage/json.py @@ -1,20 +1,38 @@ import json -def save_dict_to_json(dct, log_file): +def save_dict_to_json(dct: dict, file_: str): """ - Save dict to file. + Save dict to file. Inverse to `load_dict_from_json`. + + Parameters + ---------- + dct: + The dictionary to write to file. + file_: + Name of the file to write to. """ - with open(log_file, 'w') as f: + with open(file_, 'w') as f: json.dump(dct, f) -def load_dict_from_json(log_file, key_type: type = int): +def load_dict_from_json(file_: str, key_type: type = int): """ - Read in json file. - Convert keys to `key_type'. + Read in json file. Convert keys to `key_type'. + Inverse to `save_dict_to_json`. + + Parameters + ---------- + file_: + Name of the file to read in. + key_type: + Type to convert the keys into. + + Returns + ------- + dct: The json file contents. """ - with open(log_file, 'r') as f: + with open(file_, 'r') as f: _dct = json.load(f) dct = {} for key, val in _dct.items(): diff --git a/pyabc/visualization/data.py b/pyabc/visualization/data.py index 88f0c4437..98cd6a18c 100644 --- a/pyabc/visualization/data.py +++ b/pyabc/visualization/data.py @@ -22,26 +22,24 @@ def plot_data_callback( Parameters ---------- - history: History The history object to use. f_plot: Callable, optional Function to plot a single summary statistic. Takes the parameters - (sum_stat, weight, ax, **kwargs). + ``(sum_stat, weight, ax, **kwargs)``. f_plot_aggregated: Callable Function to plot aggregated values on summary statistics. Takes - the parameters (sum_stats, weights, ax, **kwargs). + the parameters ``(sum_stats, weights, ax, **kwargs)``. t: int, optional Time point to extract data from the history for. ax: maplotlib.axes.Axes Axis object for the plot. This object is not touched directly and can thus be also e.g. a list of axis objects. - **kwargs: - Additional arguments are passed on to the plotting functions. + + Additional arguments are passed on to the plotting functions. Returns ------- - ax: Axis of the generated plot. """ weights, sum_stats = history.get_weighted_sum_stats(t=t) diff --git a/pyabc/visualization/kde.py b/pyabc/visualization/kde.py index cbd36037d..8b21f237c 100644 --- a/pyabc/visualization/kde.py +++ b/pyabc/visualization/kde.py @@ -154,6 +154,7 @@ def plot_kde_1d(df, w, x, xmin=None, xmax=None, if ax is None: _, ax = plt.subplots() ax.plot(x_vals, pdf, **kwargs) + ax.set_ylim(bottom=min(ax.get_ylim()[0], 0)) ax.set_xlabel(x) ax.set_ylabel("Posterior") ax.set_xlim(xmin, xmax) diff --git a/test/test_populationstrategy.py b/test/test_populationstrategy.py index aa5de182f..36ef8253d 100644 --- a/test/test_populationstrategy.py +++ b/test/test_populationstrategy.py @@ -4,7 +4,7 @@ PopulationStrategy) from pyabc.transition import MultivariateNormalTransition import pandas as pd -import scipy as sp +import numpy as np def Adaptive(): @@ -25,12 +25,12 @@ def population_strategy(request): def test_adapt_single_model(population_strategy: PopulationStrategy): n = 10 - df = pd.DataFrame([{"s": sp.rand()} for _ in range(n)]) - w = sp.ones(n) / n + df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) + w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) - population_strategy.adapt_population_size([kernel], sp.array([1.])) + population_strategy.adapt_population_size([kernel], np.array([1.])) assert population_strategy.nr_particles > 0 @@ -38,20 +38,20 @@ def test_adapt_two_models(population_strategy: PopulationStrategy): n = 10 kernels = [] for _ in range(2): - df = pd.DataFrame([{"s": sp.rand()} for _ in range(n)]) - w = sp.ones(n) / n + df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) + w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) - population_strategy.adapt_population_size(kernels, sp.array([.7, .2])) + population_strategy.adapt_population_size(kernels, np.array([.7, .2])) assert population_strategy.nr_particles > 0 def test_no_parameters(population_strategy: PopulationStrategy): n = 10 df = pd.DataFrame(index=list(range(n))) - w = sp.ones(n) / n + w = np.ones(n) / n kernels = [] for _ in range(2): @@ -59,7 +59,7 @@ def test_no_parameters(population_strategy: PopulationStrategy): kernel.fit(df, w) kernels.append(kernel) - population_strategy.adapt_population_size(kernels, sp.array([.7, .3])) + population_strategy.adapt_population_size(kernels, np.array([.7, .3])) assert population_strategy.nr_particles > 0 @@ -69,36 +69,36 @@ def test_one_with_one_without_parameters(population_strategy: kernels = [] df_without = pd.DataFrame(index=list(range(n))) - w_without = sp.ones(n) / n + w_without = np.ones(n) / n kernel_without = MultivariateNormalTransition() kernel_without.fit(df_without, w_without) kernels.append(kernel_without) - df_with = pd.DataFrame([{"s": sp.rand()} for _ in range(n)]) - w_with = sp.ones(n) / n + df_with = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) + w_with = np.ones(n) / n kernel_with = MultivariateNormalTransition() kernel_with.fit(df_with, w_with) kernels.append(kernel_with) - population_strategy.adapt_population_size(kernels, sp.array([.7, .3])) + population_strategy.adapt_population_size(kernels, np.array([.7, .3])) assert population_strategy.nr_particles > 0 def test_transitions_not_modified(population_strategy: PopulationStrategy): n = 10 kernels = [] - test_points = pd.DataFrame([{"s": sp.rand()} for _ in range(n)]) + test_points = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) for _ in range(2): - df = pd.DataFrame([{"s": sp.rand()} for _ in range(n)]) - w = sp.ones(n) / n + df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) + w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) test_weights = [k.pdf(test_points) for k in kernels] - population_strategy.adapt_population_size(kernels, sp.array([.7, .2])) + population_strategy.adapt_population_size(kernels, np.array([.7, .2])) after_adaptation_weights = [k.pdf(test_points) for k in kernels] diff --git a/test/test_resume_run.py b/test/test_resume_run.py index c4a7b20fd..1a8a2c81e 100644 --- a/test/test_resume_run.py +++ b/test/test_resume_run.py @@ -1,6 +1,6 @@ from pyabc import (ABCSMC, Distribution, RV) -import scipy as sp import pytest +import numpy as np @pytest.fixture(params=[0, None]) @@ -10,7 +10,7 @@ def gt_model(request): def test_resume(db_path, gt_model): def model(parameter): - return {"data": parameter["mean"] + sp.randn()} + return {"data": parameter["mean"] + np.random.randn()} prior = Distribution(mean=RV("uniform", 0, 5)) diff --git a/test/test_samplers.py b/test/test_samplers.py index 297b28fa0..5fd42043c 100644 --- a/test/test_samplers.py +++ b/test/test_samplers.py @@ -1,7 +1,6 @@ import multiprocessing import pytest import numpy as np -import scipy as sp import scipy.stats as st from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor from pyabc import (ABCSMC, RV, Distribution, @@ -155,7 +154,7 @@ def model(args): mp = history.get_model_probabilities(history.max_t) def p_y_given_model(mu_x_model): - res = st.norm(mu_x_model, sp.sqrt(sigma**2 + sigma**2)).pdf(y_observed) + res = st.norm(mu_x_model, np.sqrt(sigma**2 + sigma**2)).pdf(y_observed) return res p1_expected_unnormalized = p_y_given_model(mu_x_1) @@ -176,7 +175,7 @@ def p_y_given_model(mu_x_model): except KeyError: mp1 = 0 - assert abs(mp0 - p1_expected) + abs(mp1 - p2_expected) < sp.inf + assert abs(mp0 - p1_expected) + abs(mp1 - p2_expected) < np.inf # check that sampler only did nr_particles samples in first round pops = history.get_all_populations() diff --git a/test/test_stop_sampling.py b/test/test_stop_sampling.py index c3504c6c2..9639b665e 100644 --- a/test/test_stop_sampling.py +++ b/test/test_stop_sampling.py @@ -1,14 +1,14 @@ from pyabc import ABCSMC, Distribution from pyabc.sampler import MulticoreEvalParallelSampler, SingleCoreSampler import scipy.stats as st -import scipy as sp +import numpy as np set_acc_rate = 0.2 def model(x): - return {"par": x["par"] + sp.randn()} + return {"par": x["par"] + np.random.randn()} def dist(x, y): diff --git a/test/test_storage.py b/test/test_storage.py index cdaa0c2cd..3c66e5c91 100644 --- a/test/test_storage.py +++ b/test/test_storage.py @@ -1,12 +1,12 @@ from pyabc import History import pytest import os +import pyabc from pyabc.parameters import Parameter from pyabc.population import Particle, Population import numpy as np -import tempfile -import scipy as sp import pandas as pd +import tempfile from rpy2.robjects import r from rpy2.robjects import pandas2ri from rpy2.robjects.conversion import localconverter @@ -77,13 +77,13 @@ def rand_pop_list(m: int): Particle(m=m, parameter=Parameter({"a": np.random.randint(10), "b": np.random.randn()}), - weight=sp.rand() * 42, + weight=np.random.rand() * 42, accepted_sum_stats=[{"ss_float": 0.1, "ss_int": 42, "ss_str": "foo bar string", - "ss_np": sp.rand(13, 42), + "ss_np": np.random.rand(13, 42), "ss_df": example_df()}], - accepted_distances=[sp.rand()]) + accepted_distances=[np.random.rand()]) for _ in range(np.random.randint(10) + 3)] return pop @@ -200,8 +200,8 @@ def test_single_particle_save_load_np_int64(history: History): def test_sum_stats_save_load(history: History): - arr = sp.random.rand(10) - arr2 = sp.random.rand(10, 2) + arr = np.random.rand(10) + arr2 = np.random.rand(10, 2) particle_list = [ Particle(m=0, parameter=Parameter({"a": 23, "b": 12}), @@ -326,7 +326,6 @@ def test_population_retrieval(history: History): assert history.alive_models(1) == [0] assert history.alive_models(2) == [0, 5] assert history.alive_models(3) == [30] - print("ID", history.id) def test_population_strategy_storage(history): @@ -362,7 +361,7 @@ def test_observed_sum_stats(history_uninitialized: History, gt_model): "s4": np.random.rand(10)} h.store_initial_data(gt_model, {}, obs_sum_stats, {}, [""], "", "", "") - h2 = History(h.db_identifier) + h2 = History(h.db) loaded_sum_stats = h2.observed_sum_stat() for k in ["s1", "s2", "s3"]: @@ -380,7 +379,7 @@ def test_model_name_load(history_uninitialized: History): model_names = ["m1", "m2", "m3"] h.store_initial_data(0, {}, {}, {}, model_names, "", "", "") - h2 = History(h.db_identifier) + h2 = History(h.db) model_names_loaded = h2.model_names() assert model_names == model_names_loaded @@ -390,7 +389,7 @@ def test_model_name_load_no_gt_model(history_uninitialized: History): model_names = ["m1", "m2", "m3"] h.store_initial_data(None, {}, {}, {}, model_names, "", "", "") - h2 = History(h.db_identifier) + h2 = History(h.db) model_names_loaded = h2.model_names() assert model_names == model_names_loaded @@ -407,7 +406,7 @@ def test_model_name_load_single_with_pop(history_uninitialized: History): accepted_distances=[.1])] h.append_population(0, 42, Population(particle_list), 2, model_names) - h2 = History(h.db_identifier) + h2 = History(h.db) model_names_loaded = h2.model_names() assert model_names == model_names_loaded @@ -435,3 +434,24 @@ def test_update_nr_samples(history: History): def test_pickle(history: History): pickle.dumps(history) + + +def test_dict_from_and_to_json(): + dct = {1: 0.5, 2: 42, 3: [1, 2, 0.1]} + file_ = tempfile.mkstemp()[1] + pyabc.storage.save_dict_to_json(dct, file_) + re_dct = pyabc.storage.load_dict_from_json(file_) + assert dct == re_dct + + +def test_create_db(): + # temporary file name + file_ = tempfile.mkstemp(suffix=".db")[1] + + # should work just fine though file empty + pyabc.History("sqlite:///" + file_, create=False) + + # delete file and check we cannot create a History object + os.remove(file_) + with pytest.raises(ValueError): + pyabc.History("sqlite:///" + file_, create=False) diff --git a/test_nondeterministic/test_abc_smc_algorithm.py b/test_nondeterministic/test_abc_smc_algorithm.py index 2fd85d59f..d7ba7f670 100644 --- a/test_nondeterministic/test_abc_smc_algorithm.py +++ b/test_nondeterministic/test_abc_smc_algorithm.py @@ -259,7 +259,7 @@ def expected_p(a, b, n1): def test_continuous_non_gaussian(db_path, sampler): def model(args): - return {"result": sp.rand() * args['u']} + return {"result": np.random.rand() * args['u']} models = [model] models = list(map(SimpleModel, models)) @@ -279,30 +279,30 @@ def model(args): history = abc.run(minimum_epsilon, max_nr_populations=2) posterior_x, posterior_weight = history.get_distribution(0, None) posterior_x = posterior_x["u"].values - sort_indices = sp.argsort(posterior_x) - f_empirical = sp.interpolate.interp1d(sp.hstack((-200, + sort_indices = np.argsort(posterior_x) + f_empirical = np.interpolate.interp1d(np.hstack((-200, posterior_x[sort_indices], 200)), - sp.hstack((0, - sp.cumsum( + np.hstack((0, + np.cumsum( posterior_weight[ sort_indices]), 1))) @sp.vectorize def f_expected(u): - return (sp.log(u)-sp.log(d_observed)) / (- sp.log(d_observed)) * \ + return (np.log(u)-np.log(d_observed)) / (- np.log(d_observed)) * \ (u > d_observed) - x = sp.linspace(0.1, 1) - max_distribution_difference = sp.absolute(f_empirical(x) - + x = np.linspace(0.1, 1) + max_distribution_difference = np.absolute(f_empirical(x) - f_expected(x)).max() assert max_distribution_difference < 0.12 def mean_and_std(values, weights): mean = (values * weights).sum() - std = sp.sqrt(((values - mean)**2 * weights).sum()) + std = np.sqrt(((values - mean)**2 * weights).sum()) return mean, std @@ -335,15 +335,15 @@ def model(args): history = abc.run(minimum_epsilon, max_nr_populations=nr_populations) posterior_x, posterior_weight = history.get_distribution(0, None) posterior_x = posterior_x["x"].values - sort_indices = sp.argsort(posterior_x) - f_empirical = sp.interpolate.interp1d(sp.hstack((-200, posterior_x[sort_indices], 200)), - sp.hstack((0, sp.cumsum(posterior_weight[sort_indices]), 1))) + sort_indices = np.argsort(posterior_x) + f_empirical = sp.interpolate.interp1d(np.hstack((-200, posterior_x[sort_indices], 200)), + np.hstack((0, np.cumsum(posterior_weight[sort_indices]), 1))) - sigma_x_given_y = 1 / sp.sqrt(1 / sigma_prior**2 + 1 / sigma_ground_truth**2) + sigma_x_given_y = 1 / np.sqrt(1 / sigma_prior**2 + 1 / sigma_ground_truth**2) mu_x_given_y = sigma_x_given_y**2 * observed_data / sigma_ground_truth**2 expected_posterior_x = st.norm(mu_x_given_y, sigma_x_given_y) - x = sp.linspace(-8, 8) - max_distribution_difference = sp.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() + x = np.linspace(-8, 8) + max_distribution_difference = np.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() assert max_distribution_difference < 0.12 assert history.max_t == nr_populations-1 mean_emp, std_emp = mean_and_std(posterior_x, posterior_weight) @@ -378,15 +378,15 @@ def model(args): history = abc.run(minimum_epsilon, max_nr_populations=nr_populations) posterior_x, posterior_weight = history.get_distribution(0, None) posterior_x = posterior_x["x"].values - sort_indices = sp.argsort(posterior_x) - f_empirical = sp.interpolate.interp1d(sp.hstack((-200, posterior_x[sort_indices], 200)), - sp.hstack((0, sp.cumsum(posterior_weight[sort_indices]), 1))) + sort_indices = np.argsort(posterior_x) + f_empirical = sp.interpolate.interp1d(np.hstack((-200, posterior_x[sort_indices], 200)), + np.hstack((0, np.cumsum(posterior_weight[sort_indices]), 1))) - sigma_x_given_y = 1 / sp.sqrt(1 / sigma_x**2 + 1 / sigma_y**2) + sigma_x_given_y = 1 / np.sqrt(1 / sigma_x**2 + 1 / sigma_y**2) mu_x_given_y = sigma_x_given_y**2 * y_observed / sigma_y**2 expected_posterior_x = st.norm(mu_x_given_y, sigma_x_given_y) - x = sp.linspace(-8, 8) - max_distribution_difference = sp.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() + x = np.linspace(-8, 8) + max_distribution_difference = np.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() assert max_distribution_difference < 0.052 assert history.max_t == nr_populations-1 mean_emp, std_emp = mean_and_std(posterior_x, posterior_weight) @@ -408,7 +408,7 @@ def model(args): population_size = ConstantPopulationSize(600) parameter_given_model_prior_distribution = [Distribution(x=st.norm(0, sigma_x))] parameter_perturbation_kernels = [GridSearchCV(MultivariateNormalTransition(), - {"scaling": sp.logspace(-1, 1.5, 5)})] + {"scaling": np.logspace(-1, 1.5, 5)})] abc = ABCSMC(models, parameter_given_model_prior_distribution, MinMaxDistance(measures_to_use=["y"]), population_size, @@ -423,15 +423,15 @@ def model(args): history = abc.run(minimum_epsilon, max_nr_populations=nr_populations) posterior_x, posterior_weight = history.get_distribution(0, None) posterior_x = posterior_x["x"].values - sort_indices = sp.argsort(posterior_x) - f_empirical = sp.interpolate.interp1d(sp.hstack((-200, posterior_x[sort_indices], 200)), - sp.hstack((0, sp.cumsum(posterior_weight[sort_indices]), 1))) + sort_indices = np.argsort(posterior_x) + f_empirical = sp.interpolate.interp1d(np.hstack((-200, posterior_x[sort_indices], 200)), + np.hstack((0, np.cumsum(posterior_weight[sort_indices]), 1))) - sigma_x_given_y = 1 / sp.sqrt(1 / sigma_x**2 + 1 / sigma_y**2) + sigma_x_given_y = 1 / np.sqrt(1 / sigma_x**2 + 1 / sigma_y**2) mu_x_given_y = sigma_x_given_y**2 * y_observed / sigma_y**2 expected_posterior_x = st.norm(mu_x_given_y, sigma_x_given_y) - x = sp.linspace(-8, 8) - max_distribution_difference = sp.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() + x = np.linspace(-8, 8) + max_distribution_difference = np.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() assert max_distribution_difference < 0.052 assert history.max_t == nr_populations-1 mean_emp, std_emp = mean_and_std(posterior_x, posterior_weight) @@ -469,7 +469,7 @@ def model(args): mp = history.get_model_probabilities(history.max_t) def p_y_given_model(mu_x_model): - return st.norm(mu_x_model, sp.sqrt(sigma_y**2+sigma_x**2)).pdf(y_observed) + return st.norm(mu_x_model, np.sqrt(sigma_y**2+sigma_x**2)).pdf(y_observed) p1_expected_unnormalized = p_y_given_model(mu_x_1) p2_expected_unnormalized = p_y_given_model(mu_x_2) @@ -521,7 +521,7 @@ def model(args): mp = history.get_model_probabilities(history.max_t) def p_y_given_model(mu_x_model): - return st.norm(mu_x_model, sp.sqrt(sigma**2 + sigma**2)).pdf(y_observed) + return st.norm(mu_x_model, np.sqrt(sigma**2 + sigma**2)).pdf(y_observed) p1_expected_unnormalized = p_y_given_model(mu_x_1) p2_expected_unnormalized = p_y_given_model(mu_x_2) @@ -612,15 +612,15 @@ def model(args): history = abc.run(minimum_epsilon, max_nr_populations=nr_populations) posterior_x, posterior_weight = history.get_distribution(0, None) posterior_x = posterior_x["x"].values - sort_indices = sp.argsort(posterior_x) - f_empirical = sp.interpolate.interp1d(sp.hstack((-200, posterior_x[sort_indices], 200)), - sp.hstack((0, sp.cumsum(posterior_weight[sort_indices]), 1))) + sort_indices = np.argsort(posterior_x) + f_empirical = sp.interpolate.interp1d(np.hstack((-200, posterior_x[sort_indices], 200)), + np.hstack((0, np.cumsum(posterior_weight[sort_indices]), 1))) - sigma_x_given_y = 1 / sp.sqrt(1 / sigma_x ** 2 + 1 / sigma_y ** 2) + sigma_x_given_y = 1 / np.sqrt(1 / sigma_x ** 2 + 1 / sigma_y ** 2) mu_x_given_y = sigma_x_given_y ** 2 * y_observed / sigma_y ** 2 expected_posterior_x = st.norm(mu_x_given_y, sigma_x_given_y) - x = sp.linspace(-8, 8) - max_distribution_difference = sp.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() + x = np.linspace(-8, 8) + max_distribution_difference = np.absolute(f_empirical(x) - expected_posterior_x.cdf(x)).max() assert max_distribution_difference < 0.15 assert history.max_t == nr_populations - 1 mean_emp, std_emp = mean_and_std(posterior_x, posterior_weight) @@ -674,7 +674,7 @@ def model(args): mp = history.get_model_probabilities(history.max_t) def p_y_given_model(mu_x_model): - return st.norm(mu_x_model, sp.sqrt(sigma ** 2 + sigma ** 2)).pdf(y_observed) + return st.norm(mu_x_model, np.sqrt(sigma ** 2 + sigma ** 2)).pdf(y_observed) p1_expected_unnormalized = p_y_given_model(mu_x_1) p2_expected_unnormalized = p_y_given_model(mu_x_2) diff --git a/test_performance/test_samplerperf.py b/test_performance/test_samplerperf.py index 982766a09..dba2c6c66 100644 --- a/test_performance/test_samplerperf.py +++ b/test_performance/test_samplerperf.py @@ -3,7 +3,7 @@ import tempfile import time import pytest -import scipy as sp +import numpy as np import scipy.stats as st from pyabc import (ABCSMC, RV, Distribution, @@ -126,7 +126,7 @@ def model(args): history.get_model_probabilities(history.max_t) def p_y_given_model(mu_x_model): - res = st.norm(mu_x_model, sp.sqrt(sigma**2 + sigma**2)).pdf(y_observed) + res = st.norm(mu_x_model, np.sqrt(sigma**2 + sigma**2)).pdf(y_observed) return res p1_expected_unnormalized = p_y_given_model(mu_x_1) From c0c6a06cf66ec329b87fa82dbf17c77686c79329 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Sat, 25 Jan 2020 12:58:46 +0100 Subject: [PATCH 09/11] Feature redis pw 2 (#256) * update sampler.rst docs * fix password protection in Server and manage * add test for password protection * ignore codacy * test * test * test * tidy up docs * minor edit * update releasenotes * travis: extend time span * improve readability --- .travis.yml | 2 +- doc/releasenotes.rst | 1 + doc/sampler.rst | 200 ++++++++---------- pyabc/sampler/redis_eps/cli.py | 9 +- .../redis_eps/redis_sampler_server_starter.py | 30 ++- pyabc/sampler/redis_eps/sampler.py | 11 +- test/test_samplers.py | 14 +- 7 files changed, 148 insertions(+), 119 deletions(-) diff --git a/.travis.yml b/.travis.yml index d73be1f5f..0fcc40e29 100644 --- a/.travis.yml +++ b/.travis.yml @@ -31,7 +31,7 @@ install: # run tests script: -- travis_wait 15 python -m pytest --cov=pyabc test/test_* +- travis_wait 20 python -m pytest --cov=pyabc test/test_* - travis_wait 5 xvfb-run -a python -m pytest --cov=pyabc --cov-append test/visualization/test_* - if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 15 test/run_notebooks.sh; fi diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index fc1cd23b1..50640a49f 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -14,6 +14,7 @@ Release Notes * Add optional check whether database is non-existent, to detect typos. * Set lower bound in 1-dim KDEs to <= 0 to not wrongly display near-uniform distributions. (both #257) +* Implement redis password protection for sampler and manage routine (#256). * Make samplers available in global namespace (#249). * Implement ListTemperature (#248). * Allow plotting the relative ESS (#245). diff --git a/doc/sampler.rst b/doc/sampler.rst index 26521e99e..c172065e8 100644 --- a/doc/sampler.rst +++ b/doc/sampler.rst @@ -101,93 +101,80 @@ environments Check the :doc:`API documentation ` for more details. -How to setup a Redis based distributed cluster ----------------------------------------------- +How to set up a Redis based distributed cluster +----------------------------------------------- -Step 1: Reconfigure the redis.conf file -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -It is advised to run Redis server in protected mode. Authenticated -communication will allow only for authenticated access to communicated with -the server, and reject all unauthorised access. To run Redis server with -authentication required you need first to modify the redis.conf file. - -The redis.conf is the file that contains Redis configuration. Usually, -it can be found on `/etc/redis/`. To allow safe and secure communication, -redis.conf file should be reconfigure. You can copy the file to your home -directory and then modify it as follow: - -1. The Redis server should be configured in a way that allows it to bind to -network interfaces other than localhost (127.0.0.1). To enable that, be sure -that the bind configuration option is either commented out or modified to an -appropriate network interface IP address. +Step 0: Prepare the redis server +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +To run the redis server, use a machine which is reachable both by the main +application and by the workers. If you're on Linux, you can install redis +either via your package manager, or, if you're using anaconda, via .. code:: bash - #bind 127.0.0.1 + conda install redis -2. The password authentication must be enabled. To configure that, be sure -that the ``masterauth`` and ``requirepass`` configuration options are -uncommented, and their values are the SAME. Note: it advised to select complex -password string. +Windows is currently not officially supported by the redis developers. -.. code:: bash - - masterauth your_redis_password +It is recommended to run a redis server only with password protection, since +it otherwise accepts any incoming connection. To set up password protection +on the server, you need to modify the ``redis.conf`` file. Usually, such a file +exists under ``REDIS_INSTALL_DIR/etc/redis.conf``. You can however also set +up your own file. It suffices to add or uncomment the line .. code:: bash + + requirepass PASSWORD - requirepass your_redis_password +where `PASSWORD` should be replaced by a more secure password. -Step 2: Start a Redis server with password authentication -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Step 1: Start a redis server +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Start one machine, which is reachable by the machine running the pyABC -main application and by the workers, a Redis server, specifying the -location of the configuration file for redis server that you modify in the first -step and the port number: +In this example, we assume that the IP address of the machine running the +redis server is ``111.111.111.111`` (the default is ``localhost``), +and that the server should listen on port ``6379`` (the redis default). +If password protection is used, start the server via .. code:: bash - redis-server /path/to/redis.conf --port 6379 - -Note that if you didn't specify a port, redis will assign a default port, -that is 6379, for your server. - + redis-server /path/to/redis.conf --port 6379 -If you're on Linux, you can install redis either via your package manager -of if you're using anaconda via +If no password protection is required, instead use .. code:: bash - conda install redis + redis-server --port 6379 --protected-mode no + +You should get an output looking similar to the one below: -At this point, Windows is not officially supported by the Redis developers. -We assume for now, that the IP address of the machine running the Redis server -is 111.111.111.111. +.. literalinclude:: redis_setup/redis_start_output.txt + :language: bash -Step 3 or 4: Start pyABC +Step 2 or 3: Start pyABC ~~~~~~~~~~~~~~~~~~~~~~~~ It does not matter what you do first: starting pyABC or starting the -workers. Assuming the models, priors and the distance function are defined, -configure pyABC to use the Redis sampler +workers. In your main program, assuming the models, priors and the distance +function are defined, configure pyABC to use the redis sampler .. code:: python from pyabc.sampler import RedisEvalParallelSampler - redis_sampler = RedisEvalParallelSampler(host="111.111.111.111") + redis_sampler = RedisEvalParallelSampler(host="111.111.111.111", port=6379) abc = pyabc.ABCSMC(models, priors, distance, sampler=redis_sampler) -Note that 111.111.111.111 is the IP address of the machine running the Redis -server. Then start the ABC-SMC run as usual with +If password protection is used, in addition pass the argument +``password=PASSWORD`` to the RedisEvalParallelSampler. + +Then start the ABC-SMC run as usual with .. code:: python @@ -197,64 +184,37 @@ server. Then start the ABC-SMC run as usual with passing the stopping conditions. -Step 3 or 4: Start the workers +Step 2 or 3: Start the workers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ It does not matter what you do first: starting pyABC or starting the workers. You can even dynamically add workers after the sampling has started. Start as many workers as you wish on the machines you wish. Up to 10,000 workers should not pose any problem if the model evaluation times are on the -second scale or longer. +scale or seconds or longer. You start workers on your cluster via .. code:: bash - abc-redis-worker --host=111.111.111.111 --port 6379 --password mypass - -Again, 111.111.111.111 is the IP address of the machine running the Redis -server and we use the default port number. You also need to specify the password -that you use in the configuration file ``redis.conf``. In our case that password -was ``mypass``. You should get an output similar to + abc-redis-worker --host=111.111.111.111 --port=6379 +If password protection is used, you need to append ``--password=PASSWORD``. +You should get an output similar to .. code:: bash INFO:REDIS-WORKER:Start redis worker. Max run time 7200.0s, PID=2731 -Note that the ``abc-redis-worker`` command also has options to set the +The ``abc-redis-worker`` command has further options (see them via +``abc-redis-worker --help``), in particular to set the maximal runtime of a worker, e.g. ``--runtime=2h``, ``--runtime=3600s``, ``--runtime=2d``, to start a worker running for 2 hours, 3600 seconds -or 2 days. -The default is 2 hours. It is OK if a worker +or 2 days (the default is 2 hours). It is OK if a worker stops during the sampling of a generation. You can add new workers during -the sampling process. +the sampling process at any time. The ``abc-redis-worker`` command also has an option ``--processes`` which -allows you to start several worker procecces in parallel. -This might be handy in situations where you have to use a whole cluster node -with several cores. - -Optional: Running redis server without password authentication -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -In some cases, a user might want to run the redis server without password -authentication. To do so, you can start the redis server without specifying -the location of the ``redis.conf`` file and use the flag ``--protected-mode`` -with value no - -.. code:: bash - - redis-server --protected-mode no - -You should get an output looking similar to the one below: - -.. literalinclude:: redis_setup/redis_start_output.txt - :language: bash - - -Later, to start workers, you don't need use the password flag - -.. code:: bash - - - abc-redis-worker --host=111.111.111.111 +allows you to start several worker procecces in parallel, e.g. +``--processes=12``. This might be handy in situations where you have to use +a whole cluster node with several cores. Optional: Monitoring @@ -268,12 +228,13 @@ To monitor the ongoing sampling, execute abc-redis-manager info --host=111.111.111.111 -again, assuming 111.111.111.111 is the IP of the Redis server. If no sampling -has happened yet, the output should look like +If password protection is used, you need to specify the password via +``--password=PASSWORD``. +If no sampling has happened yet, the output should look like .. code:: bash - Workers=None Evaluations=None Particles=None + Workers=None Evaluations=None Acceptances=None/None The keys are to be read as follows: @@ -282,11 +243,9 @@ The keys are to be read as follows: at the end of a generation. * Evaluations: Number of accumulated model evaluations for the current generations. This is a sum across all workers. -* Particles: Number of particles which remain to be accepted. - This number decreases over the - course of a population and reaches 0 (or a negative number due to excess - sampling) at the end of a population. At the very start, this is just the - population size. +* Acceptances: In ``i/n``, ``i`` particles out of a requested population + size of ``n`` have been accepted already. It can be ``i>n`` at the end of + a population due to excess sampling. Optional: Stopping workers @@ -324,15 +283,30 @@ pyABC has been successfully employed on various high-performance computing (HPC) Long-running master process ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -While most of the work happens on parallel workers, pyABC requires one long-running master process in the background for all of the analysis (or rather two processes, namely the master process running the execution script, and in addition possibly a task scheduler like the redis server). If the HPC infrastructure does not allow for such long-running processes with low CPU and memory requirements, one has to find a way around. Eventually, it is planned for pyABC to support loss-free automatic checkpointing and restarting, but presently this is not yet implemented. If possible, the master process can be run on external servers, login nodes, or on execution nodes while taking maximum runtimes and reliability of server and connections into consideration. +While most of the work happens on parallel workers, pyABC requires one +long-running master process in the background for all of the analysis +(or rather two processes, namely the master process running the execution +script, and in addition possibly a task scheduler like the redis server). +If the HPC infrastructure does not allow for such long-running processes +with low CPU and memory requirements, one has to find a way around. +Eventually, it is planned for pyABC to support loss-free automatic +checkpointing and restarting, but presently this is not yet implemented. +If possible, the master process can be run on external servers, login nodes, +or on execution nodes while taking maximum runtimes and reliability of +server and connections into consideration. Job scheduling ~~~~~~~~~~~~~~ -HPC environments usually employ a job scheduler for distributing work to the execution nodes. Here, we shortly outline how pyABC can be integrated in such a setup. Exemplarily, we use a redis sampler, usage of in particular the dask sampler being similar. +HPC environments usually employ a job scheduler for distributing work to the +execution nodes. Here, we shortly outline how pyABC can be integrated in such +a setup. Exemplarily, we use a redis sampler, usage of in particular the dask +sampler being similar. -Let us consider the widely used job scheduler `slurm `_. First, we need a script `script_redis_worker.sh` that starts the redis worker: +Let us consider the widely used job scheduler +`slurm `_. First, we need a script +``script_redis_worker.sh`` that starts the redis worker: .. code:: bash @@ -351,9 +325,13 @@ Let us consider the widely used job scheduler `slurm abs-redis-worker --host={host_ip} --port={port} --runtime={runtime} \ --processes={n_processes} -Here, `n_processes` defines the number of processes started for that batch job via multiprocessing. Some HPC setups prefer larger batch jobs, e.g. on a node level, so here each job can already be given some parallelity. The `SBATCH` macros define the slurm setting to be used. +Here, ``n_processes`` defines the number of processes started for that batch +job via multiprocessing. Some HPC setups prefer larger batch jobs, e.g. on a +node level, so here each job can already be given some parallelity. The +``SBATCH`` macros define the slurm setting to be used. -The above script would be submitted to the slurm job manager via `sbatch`. It makes sense to define a script for this as well: +The above script would be submitted to the slurm job manager via ``sbatch``. +It makes sense to define a script for this as well: .. code:: bash @@ -364,7 +342,8 @@ The above script would be submitted to the slurm job manager via `sbatch`. It ma sbatch script_redis_worker.sh done -Here, `n_jobs` would be the number of jobs submitted. When the job scheduler is based on qsub, e.g. SGE/UGE, instead use a script like +Here, ``n_jobs`` would be the number of jobs submitted. When the job scheduler +is based on qsub, e.g. SGE/UGE, instead use a script like .. code:: bash @@ -375,14 +354,23 @@ Here, `n_jobs` would be the number of jobs submitted. When the job scheduler is qsub -o {output_file_name} -e {error_file_name} \ script_redis_worker.sh -and adapt the worker script. For both, there exist many more configuration options. For further details see the respective documentation. +and adapt the worker script. For both, there exist many more configuration +options. For further details see the respective documentation. -Note that when planning for the number of overall redis workers, batches, and cpus per batch, also the parallelization on the level of the simulations has to be taken into account. Also, memory requirements should be checked in advance. +Note that when planning for the number of overall redis workers, batches, and +cpus per batch, also the parallelization on the level of the simulations has +to be taken into account. Also, memory requirements should be checked in +advance. Pickling -------- +.. note:: + + This section is of interest to developers, of if you encounter memory + problems. + For most of the samplers, pyABC uses `cloudpickle `_ to serialize objects over the network and run simulations on remote nodes. In particular, this diff --git a/pyabc/sampler/redis_eps/cli.py b/pyabc/sampler/redis_eps/cli.py index 5817d849a..ad988b972 100644 --- a/pyabc/sampler/redis_eps/cli.py +++ b/pyabc/sampler/redis_eps/cli.py @@ -253,16 +253,17 @@ def _work(host="localhost", port=6379, runtime="2h", password=None): "if workers were unexpectedly killed.") @click.option('--host', default="localhost", help='Redis host.') @click.option('--port', default=6379, type=int, help='Redis port.') +@click.option('--password', default=None, type=str, help='Redis password.') @click.argument('command', type=str) -def manage(command, host="localhost", port=6379): +def manage(command, host="localhost", port=6379, password=None): """ Corresponds to the entry point abc-redis-manager. """ - return _manage(command, host=host, port=port) + return _manage(command, host=host, port=port, password=password) -def _manage(command, host="localhost", port=6379): - redis = StrictRedis(host=host, port=port) +def _manage(command, host="localhost", port=6379, password=None): + redis = StrictRedis(host=host, port=port, password=password) if command == "info": pipe = redis.pipeline() pipe.get(N_WORKER) diff --git a/pyabc/sampler/redis_eps/redis_sampler_server_starter.py b/pyabc/sampler/redis_eps/redis_sampler_server_starter.py index 73fb67ce1..2b77c0df8 100644 --- a/pyabc/sampler/redis_eps/redis_sampler_server_starter.py +++ b/pyabc/sampler/redis_eps/redis_sampler_server_starter.py @@ -1,6 +1,7 @@ from time import sleep from subprocess import Popen from multiprocessing import Process +import tempfile import psutil from .cli import work, _manage from .sampler import RedisEvalParallelSampler @@ -9,27 +10,46 @@ class RedisEvalParallelSamplerServerStarter(RedisEvalParallelSampler): """ Simple routine to start a redis-server with 2 workers for test purposes. + For the arguments see the base class. """ - def __init__(self, host="localhost", port=6379, batch_size=1, - workers=2, processes_per_worker=1): + def __init__(self, + host: str = "localhost", + port: int = 6379, + password: str = None, + batch_size: int = 1, + workers: int = 2, + processes_per_worker: int = 1): # start server conn = psutil.net_connections() ports = [c.laddr[1] for c in conn] port = max(ports) + 1 self.__port = port - self.__redis_server = Popen(["redis-server", "--port", str(port)]) + self.__password = password + + # create config file + maybe_redis_conf = [] + if password is not None: + fname = tempfile.mkstemp()[1] + with open(fname, 'w') as f: + f.write(f"requirepass {password}\n") + maybe_redis_conf = [fname] + + self.__redis_server = Popen( # nosec + ["redis-server", *maybe_redis_conf, "--port", str(port)]) # give redis-server time to start sleep(1) - super().__init__(host, port, batch_size=batch_size) + super().__init__(host, port, password, batch_size=batch_size) # initiate worker processes + maybe_password = [] if password is None else ["--password", password] self.__worker = [ Process(target=work, args=(["--host", "localhost", "--port", str(port), + *maybe_password, "--processes", str(processes_per_worker)],), daemon=False) for _ in range(workers) @@ -44,7 +64,7 @@ def cleanup(self): Cleanup workers and server. """ # send stop signal to workers - _manage("stop", port=self.__port) + _manage("stop", port=self.__port, password=self.__password) for p in self.__worker: # wait for workers to join p.join() diff --git a/pyabc/sampler/redis_eps/sampler.py b/pyabc/sampler/redis_eps/sampler.py index d2b39865a..4c28cf438 100644 --- a/pyabc/sampler/redis_eps/sampler.py +++ b/pyabc/sampler/redis_eps/sampler.py @@ -46,18 +46,25 @@ class RedisEvalParallelSampler(Sampler): Port of the Redis server. Default is 6379. + password: str, optional + Password for a protected server. Default is None (no protection). + batch_size: int, optional Number of model evaluations the workers perform before contacting the REDIS server. Defaults to 1. Increase this value if model evaluation times are short or the number of workers is large to reduce communication overhead. """ - def __init__(self, host="localhost", port=6379, batch_size=1): + def __init__(self, + host: str = "localhost", + port: int = 6379, + password: str = None, + batch_size: int = 1): super().__init__() logger.debug( f"Redis sampler: host={host} port={port}") # handles the connection to the redis-server - self.redis = StrictRedis(host=host, port=port) + self.redis = StrictRedis(host=host, port=port, password=password) self.batch_size = batch_size def n_worker(self): diff --git a/test/test_samplers.py b/test/test_samplers.py index 5fd42043c..7630b9f2e 100644 --- a/test/test_samplers.py +++ b/test/test_samplers.py @@ -220,7 +220,6 @@ def test_redis_multiprocess(): def simulate_one(): accepted = np.random.randint(2) - print(accepted) return Particle(0, {}, 0.1, [], [], accepted) sample = sampler.sample_until_n_accepted(10, simulate_one) @@ -251,3 +250,16 @@ def distance(s0, s1): abc.run(minimum_epsilon=.1, max_nr_populations=3) sampler.cleanup() + + +def test_redis_pw_protection(): + sampler = RedisEvalParallelSamplerServerStarter( # nosec + password="daenerys", port=8888) + + def simulate_one(): + accepted = np.random.randint(2) + return Particle(0, {}, 0.1, [], [], accepted) + + sample = sampler.sample_until_n_accepted(10, simulate_one) + assert 10 == len(sample.get_accepted_population()) + sampler.cleanup() From 6f7d7b8e53ff000c4936bb06f1de0bc92e98e1d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Sat, 25 Jan 2020 13:18:32 +0100 Subject: [PATCH 10/11] Poisson kernel: add optimal c (#260) * add poisson optimal c * tidy up code * fix error --- pyabc/distance/kernel.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/pyabc/distance/kernel.py b/pyabc/distance/kernel.py index 5286d8dbc..d338b0b2d 100644 --- a/pyabc/distance/kernel.py +++ b/pyabc/distance/kernel.py @@ -246,7 +246,7 @@ def initialize( if not callable(self.var): self.var = np.array(self.var) * np.ones(dim) - # cache pdf_max (from now on __call__ can be used) + # cache pdf_max if self.pdf_max is None and not callable(self.var): # take value at observed summary statistics self.pdf_max = self(x_0, x_0) @@ -331,7 +331,7 @@ def initialize( if not callable(self.scale): self.scale = np.array(self.scale) * np.ones(dim) - # cache pdf_max (from now on __call__ can be used) + # cache pdf_max if self.pdf_max is None and not callable(self.scale): # take value at observed summary statistics self.pdf_max = self(x_0, x_0) @@ -399,7 +399,7 @@ def initialize( get_all_sum_stats=get_all_sum_stats, x_0=x_0) - # cache pdf_max (from now on __call__ can be used) + # cache pdf_max if self.pdf_max is None and not callable(self.p): # take value at observed summary statistics self.pdf_max = binomial_pdf_max( @@ -455,7 +455,11 @@ def initialize( get_all_sum_stats=get_all_sum_stats, x_0=x_0) - # pdf_max is not computed + # cache pdf_max + if self.pdf_max is None: + # take value at observed summary statistics + # this is the optimal value + self.pdf_max = self(x_0, x_0) def __call__( self, From 9eb3e8a2673425a12cd0cacfa607639b42d72ea0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Sun, 26 Jan 2020 20:19:20 +0100 Subject: [PATCH 11/11] add arr_ax argument to plot_kde_matrix(_highlevel) for easier integration (#261) --- pyabc/visualization/kde.py | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/pyabc/visualization/kde.py b/pyabc/visualization/kde.py index 8b21f237c..a2cadb632 100644 --- a/pyabc/visualization/kde.py +++ b/pyabc/visualization/kde.py @@ -368,7 +368,7 @@ def plot_kde_matrix_highlevel( history, m: int = 0, t: int = None, limits=None, colorbar: bool = True, height: float = 2.5, numx: int = 50, numy: int = 50, refval=None, refval_color='C1', - kde=None): + kde=None, arr_ax=None): """ Plot a KDE matrix for 1- and 2-dim marginals of the parameter samples. @@ -402,21 +402,24 @@ def plot_kde_matrix_highlevel( The kernel density estimator to use for creating a smooth density from the sample. If None, a multivariate normal kde with cross-validated scaling is used. + arr_ax: + Array of axes objects to use. Returns ------- - arr_ax: Array of the generated plots' axes. + arr_ax: + Array of the generated plots' axes. """ df, w = history.get_distribution(m=m, t=t) return plot_kde_matrix( df, w, limits, colorbar, height, numx, numy, refval, refval_color, - kde) + kde, arr_ax) def plot_kde_matrix(df, w, limits=None, colorbar=True, height=2.5, numx=50, numy=50, refval=None, refval_color='C1', - kde=None): + kde=None, arr_ax=None): """ Plot a KDE matrix for 1- and 2-dim marginals of the parameter samples. @@ -431,14 +434,19 @@ def plot_kde_matrix(df, w, limits=None, colorbar=True, height=2.5, Returns ------- - arr_ax: Array of the generated plots' axes. + arr_ax: + Array of the generated plots' axes. """ n_par = df.shape[1] par_names = list(df.columns.values) - fig, arr_ax = plt.subplots(nrows=n_par, ncols=n_par, - sharex=False, sharey=False, - figsize=(height * n_par, height * n_par)) + + if arr_ax is None: + fig, arr_ax = plt.subplots(nrows=n_par, ncols=n_par, + sharex=False, sharey=False, + figsize=(height * n_par, height * n_par)) + else: + fig = arr_ax[0, 0].get_figure() if limits is None: limits = {}