From c3d6d990d09d7a2ab63f1ed359ada1805eb78e1f Mon Sep 17 00:00:00 2001 From: Kyle Meyer Date: Sun, 31 May 2015 23:39:00 -0400 Subject: [PATCH 01/24] Add CSV backend This has a couple of advantages over the Text backend. 1. The values are stored as in a table per chain, not a file per variable. This is easier to inspect and work with directly if desired (e.g., with pd.read_csv). 2. Values are stored during sampling, not kept in memory. --- pymc3/backends/__init__.py | 11 +- pymc3/backends/base.py | 4 + pymc3/backends/csv.py | 248 ++++++++++++++++++++++++++++++++ pymc3/backends/sqlite.py | 2 + pymc3/tests/test_csv_backend.py | 121 ++++++++++++++++ 5 files changed, 382 insertions(+), 4 deletions(-) create mode 100644 pymc3/backends/csv.py create mode 100644 pymc3/tests/test_csv_backend.py diff --git a/pymc3/backends/__init__.py b/pymc3/backends/__init__.py index d5cc8dba1d..f0a6d1f2f0 100644 --- a/pymc3/backends/__init__.py +++ b/pymc3/backends/__init__.py @@ -4,11 +4,11 @@ ------------------ 1. NumPy array (pymc3.backends.NDArray) -2. Text files (pymc3.backends.Text) +2. Plain text formats (pymc3.backends.Text and pymc3.backends.CSV) 3. SQLite (pymc3.backends.SQLite) -The NumPy arrays and text files both hold the entire trace in memory, -whereas SQLite commits the trace to the database while sampling. +The NDArray and Text backend both hold the entire trace in memory, +whereas CSV and SQLite backends store the values while sampling. Selecting a backend ------------------- @@ -107,13 +107,16 @@ If the traces are stored on disk, then a `load` function should also be defined that returns a MultiTrace object. -For specific examples, see pymc3.backends.{ndarray,text,sqlite}.py. +For specific examples, see pymc3.backends.{ndarray,text,csv,sqlite}.py. """ from ..backends.ndarray import NDArray from ..backends.text import Text +from ..backends.csv import CSV from ..backends.sqlite import SQLite _shortcuts = {'text': {'backend': Text, 'name': 'mcmc'}, + 'csv': {'backend': CSV, + 'name': 'mcmc'}, 'sqlite': {'backend': SQLite, 'name': 'mcmc.sqlite'}} diff --git a/pymc3/backends/base.py b/pymc3/backends/base.py index c918e5df96..41b34d6d93 100644 --- a/pymc3/backends/base.py +++ b/pymc3/backends/base.py @@ -7,6 +7,10 @@ from ..model import modelcontext +class BackendError(Exception): + pass + + class BaseTrace(object): """Base trace object diff --git a/pymc3/backends/csv.py b/pymc3/backends/csv.py new file mode 100644 index 0000000000..95d9495a56 --- /dev/null +++ b/pymc3/backends/csv.py @@ -0,0 +1,248 @@ +"""CSV file trace backend + +Store and retrieve sampling values from CSV file. + +CSV file format +--------------- + +Sampling values for each chain are saved in a separate file (under a +directory specified by the `name` argument). The rows correspond to +sampling iterations. The column names consist of variable names and +index labels. For example, the heading + + x,y__0_0,y__0_1,y__1_0,y__1_1,y__2_0,y__2_1 + +represents two variables, x and y, where x is a scalar and y has a +shape of (3, 2). +""" +from glob import glob +import numpy as np +import os +import pandas as pd +import warnings + +from ..backends import base + + +class CSV(base.BaseTrace): + """CSV trace object + + Parameters + ---------- + name : str + Name of directory to store CSV files in + model : Model + If None, the model is taken from the `with` context. + vars : list of variables + Sampling values will be stored for these variables. If None, + `model.unobserved_RVs` is used. + """ + def __init__(self, name, model=None, vars=None): + if not os.path.exists(name): + os.mkdir(name) + super(CSV, self).__init__(name, model, vars) + + self.flat_names = {v: _create_flat_names(v, shape) + for v, shape in self.var_shapes.items()} + + self.filename = None + self._fh = None + self.df = None + + ## Sampling methods + + def setup(self, draws, chain): + """Perform chain-specific setup. + + Parameters + ---------- + draws : int + Expected number of draws + chain : int + Chain number + """ + self.chain = chain + self.filename = os.path.join(self.name, 'chain-{}.csv'.format(chain)) + + cnames = [fv for v in self.varnames for fv in self.flat_names[v]] + + if os.path.exists(self.filename): + with open(self.filename) as fh: + prev_cnames = next(fh).strip().split(',') + if prev_cnames != cnames: + raise base.BackendError( + "Previous file '{}' has different variables names " + "than current model.".format(self.filename)) + self._fh = open(self.filename, 'a') + else: + self._fh = open(self.filename, 'w') + self._fh.write(','.join(cnames) + '\n') + + def record(self, point): + """Record results of a sampling iteration. + + Parameters + ---------- + point : dict + Values mapped to variable names + """ + vals = {} + for varname, value in zip(self.varnames, self.fn(point)): + vals[varname] = value.ravel() + columns = [str(val) for var in self.varnames for val in vals[var]] + self._fh.write(','.join(columns) + '\n') + + def close(self): + self._fh.close() + self._fh = None # Avoid serialization issue. + + ## Selection methods + + def _load_df(self): + if self.df is None: + self.df = pd.read_csv(self.filename) + + def __len__(self): + if self.filename is None: + return 0 + self._load_df() + return self.df.shape[0] + + def get_values(self, varname, burn=0, thin=1): + """Get values from trace. + + Parameters + ---------- + varname : str + burn : int + thin : int + + Returns + ------- + A NumPy array + """ + self._load_df() + var_df = self.df[self.flat_names[varname]] + shape = (self.df.shape[0],) + self.var_shapes[varname] + vals = var_df.values.ravel().reshape(shape) + return vals[burn::thin] + + def _slice(self, idx): + warnings.warn('Slice for CSV backend has no effect.') + + def point(self, idx): + """Return dictionary of point values at `idx` for current chain + with variables names as keys. + """ + idx = int(idx) + self._load_df() + pt = {} + for varname in self.varnames: + vals = self.df[self.flat_names[varname]].iloc[idx] + pt[varname] = vals.reshape(self.var_shapes[varname]) + return pt + + +def _create_flat_names(varname, shape): + """Return flat variable names for `varname` of `shape`. + + Examples + -------- + >>> _create_flat_names('x', (5,)) + ['x__0', 'x__1', 'x__2', 'x__3', 'x__4'] + + >>> _create_flat_names('x', (2, 2)) + ['x__0_0', 'x__0_1', 'x__1_0', 'x__1_1'] + """ + if not shape: + return [varname] + labels = (np.ravel(xs).tolist() for xs in np.indices(shape)) + labels = (map(str, xs) for xs in labels) + return ['{}__{}'.format(varname, '_'.join(idxs)) for idxs in zip(*labels)] + + +def _create_shape(flat_names): + "Determine shape from `_create_flat_names` output." + try: + _, shape_str = flat_names[-1].rsplit('__', 1) + except ValueError: + return () + return tuple(int(i) + 1 for i in shape_str.split('_')) + + +def load(name, model=None): + """Load CSV database. + + Parameters + ---------- + name : str + Name of directory that stores CSV files. + model : Model + If None, the model is taken from the `with` context. + + Returns + ------- + A MultiTrace instance + """ + files = glob(os.path.join(name, 'chain-*.csv')) + + traces = [] + for f in files: + chain = int(os.path.splitext(f)[0].rsplit('-', 1)[1]) + trace = CSV(name, model=model) + trace.chain = chain + trace.filename = f + traces.append(trace) + return base.MultiTrace(traces) + + +def dump(name, trace, chains=None): + """Store values from NDArray trace as CSV files. + + Parameters + ---------- + name : str + Name of directory to store CSV files in + trace : MultiTrace of NDArray traces + Result of MCMC run with default NDArray backend + chains : list + Chains to dump. If None, all chains are dumped. + """ + if not os.path.exists(name): + os.mkdir(name) + if chains is None: + chains = trace.chains + + var_shapes = trace._traces[chains[0]].var_shapes + flat_names = {v: _create_flat_names(v, shape) + for v, shape in var_shapes.items()} + + for chain in chains: + filename = os.path.join(name, 'chain-{}.csv'.format(chain)) + df = _trace_to_df(trace._traces[chain], flat_names) + df.to_csv(filename, index=False) + + +def _trace_to_df(trace, flat_names=None): + """Convert single-chain trace to Pandas DataFrame. + + Parameters + ---------- + trace : NDarray trace + flat_names : dict or None + A dictionary that maps each variable name in `trace` to a list + of flat variable names (e.g., ['x__0', 'x__1', ...]) + """ + if flat_names is None: + flat_names = {v: _create_flat_names(v, shape) + for v, shape in trace.var_shapes.items()} + + var_dfs = [] + for varname, shape in trace.var_shapes.items(): + vals = trace[varname] + if len(shape) == 1: + flat_vals = vals + else: + flat_vals = vals.reshape(len(trace), np.prod(shape)) + var_dfs.append(pd.DataFrame(flat_vals, columns=flat_names[varname])) + return pd.concat(var_dfs, axis=1) diff --git a/pymc3/backends/sqlite.py b/pymc3/backends/sqlite.py index bed3c602ce..348e7212a8 100644 --- a/pymc3/backends/sqlite.py +++ b/pymc3/backends/sqlite.py @@ -272,6 +272,8 @@ def close(self): self.connected = False +# TODO Consider merging `_create_colnames` and `_create_shape` with +# very similar functions in the csv backend. def _create_colnames(shape): """Return column names based on `shape`. diff --git a/pymc3/tests/test_csv_backend.py b/pymc3/tests/test_csv_backend.py new file mode 100644 index 0000000000..4cbce6a6a7 --- /dev/null +++ b/pymc3/tests/test_csv_backend.py @@ -0,0 +1,121 @@ +import numpy.testing as npt +from pymc3.tests import backend_fixtures as bf +from pymc3.backends import ndarray, csv + + +class TestCSV0dSampling(bf.SamplingTestCase): + backend = csv.CSV + name = 'csv-db' + shape = () + + +class TestCSV1dSampling(bf.SamplingTestCase): + backend = csv.CSV + name = 'csv-db' + shape = 2 + + +class TestCSV2dSampling(bf.SamplingTestCase): + backend = csv.CSV + name = 'csv-db' + shape = (2, 3) + + +class TestCSV0dSelection(bf.SelectionNoSliceTestCase): + backend = csv.CSV + name = 'csv-db' + shape = () + + +class TestCSV1dSelection(bf.SelectionNoSliceTestCase): + backend = csv.CSV + name = 'csv-db' + shape = 2 + + +class TestCSV2dSelection(bf.SelectionNoSliceTestCase): + backend = csv.CSV + name = 'csv-db' + shape = (2, 3) + + +class TestCSVDumpLoad(bf.DumpLoadTestCase): + backend = csv.CSV + load_func = staticmethod(csv.load) + name = 'csv-db' + shape = (2, 3) + + +class TestCSVDumpFunction(bf.BackendEqualityTestCase): + backend0 = backend1 = ndarray.NDArray + name0 = None + name1 = 'csv-db' + shape = (2, 3) + + @classmethod + def setUpClass(cls): + super(TestCSVDumpFunction, cls).setUpClass() + csv.dump(cls.name1, cls.mtrace1) + with cls.model: + cls.mtrace1 = csv.load(cls.name1) + + +class TestTraceToDf(bf.ModelBackendSampledTestCase): + backend = ndarray.NDArray + name = 'csv-db' + shape = (2, 3) + + def test_trace_to_df(self): + mtrace = self.mtrace + df = csv._trace_to_df(mtrace._traces[0]) + self.assertEqual(len(mtrace), df.shape[0]) + + checked = False + for varname in self.test_point.keys(): + vararr = mtrace.get_values(varname, chains=0) + ## With `shape` above, only one variable has to have that + ## `shape`. + if vararr.shape[1:] != self.shape: + continue + npt.assert_equal(vararr[:, 0, 0], df[varname + '__0_0'].values) + npt.assert_equal(vararr[:, 1, 0], df[varname + '__1_0'].values) + npt.assert_equal(vararr[:, 1, 2], df[varname + '__1_2'].values) + checked = True + self.assertTrue(checked) + +class TestNDArrayCSVEquality(bf.BackendEqualityTestCase): + backend0 = ndarray.NDArray + name0 = None + backend1 = csv.CSV + name1 = 'csv-db' + shape = (2, 3) + + +def test_create_flat_names_0d(): + shape = () + result = csv._create_flat_names('x', shape) + expected = ['x'] + assert result == expected + assert csv._create_shape(result) == shape + + +def test_create_flat_names_1d(): + shape = 2, + result = csv._create_flat_names('x', shape) + expected = ['x__0', 'x__1'] + assert result == expected + assert csv._create_shape(result) == shape + + +def test_create_flat_names_2d(): + shape = 2, 3 + result = csv._create_flat_names('x', shape) + expected = ['x__0_0', 'x__0_1', 'x__0_2', + 'x__1_0', 'x__1_1', 'x__1_2'] + assert result == expected + assert csv._create_shape(result) == shape + + +def test_create_flat_names_3d(): + shape = 2, 3, 4 + assert csv._create_shape(csv._create_flat_names('x', shape)) == shape From e507cf11a9dcd81208183732cd6db3b468d8687b Mon Sep 17 00:00:00 2001 From: Kyle Meyer Date: Fri, 5 Jun 2015 21:00:03 -0400 Subject: [PATCH 02/24] Add pandas as hard dependency --- readme.md | 6 ++++-- setup.py | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/readme.md b/readme.md index 638bfa4dda..7885546975 100644 --- a/readme.md +++ b/readme.md @@ -46,11 +46,13 @@ Another option is to clone the repository and install PyMC using `python setup.p ## Dependencies -PyMC is tested on Python 2.7 and 3.3 and depends on Theano, NumPy, SciPy, and Matplotlib (see setup.py for version information). +PyMC is tested on Python 2.7 and 3.3 and depends on Theano, NumPy, +SciPy, Pandas, and Matplotlib (see setup.py for version information). ### Optional -The GLM submodule relies on Pandas and Patsy. +In addtion to the above dependencies, the GLM submodule relies on +Patsy. [`scikits.sparse`](https://github.com/njsmith/scikits-sparse) enables sparse scaling matrices which are useful for large problems. Installation on Ubuntu is easy: diff --git a/setup.py b/setup.py index bf20d02416..57eb7dc4b9 100755 --- a/setup.py +++ b/setup.py @@ -27,7 +27,7 @@ 'Operating System :: OS Independent'] install_reqs = ['numpy>=1.7.1', 'scipy>=0.12.0', 'matplotlib>=1.2.1', - 'Theano<=0.7.1dev'] + 'Theano<=0.7.1dev', 'pandas>=0.15.0'] test_reqs = ['nose'] if sys.version_info[0] == 2: # py3 has mock in stdlib From 0b9a9461514dd887ff9c0b8a6408bdc040c8b2fb Mon Sep 17 00:00:00 2001 From: Kyle Meyer Date: Fri, 5 Jun 2015 20:53:04 -0400 Subject: [PATCH 03/24] Replace Text backend with CSV The main reason to keep the Text backend around was that pandas was an optional dependency. Now that this is no longer the case, the original Text backend doesn't offer any advantages over the CSV backend. (Even if someone prefers not to write to files while sampling, they can sample with the NDArray backend and then use the CSV dump function.) Rename CSV to Text. This name is more appropriate because the values being stored as plain text is the important feature, not which delimiter is used. --- pymc3/backends/__init__.py | 11 +- pymc3/backends/csv.py | 248 -------------------------- pymc3/backends/text.py | 296 ++++++++++++++++++++----------- pymc3/tests/test_csv_backend.py | 121 ------------- pymc3/tests/test_text_backend.py | 98 +++++++++- 5 files changed, 294 insertions(+), 480 deletions(-) delete mode 100644 pymc3/backends/csv.py delete mode 100644 pymc3/tests/test_csv_backend.py diff --git a/pymc3/backends/__init__.py b/pymc3/backends/__init__.py index f0a6d1f2f0..2d91f228ea 100644 --- a/pymc3/backends/__init__.py +++ b/pymc3/backends/__init__.py @@ -4,11 +4,11 @@ ------------------ 1. NumPy array (pymc3.backends.NDArray) -2. Plain text formats (pymc3.backends.Text and pymc3.backends.CSV) +2. Text files (pymc3.backends.Text) 3. SQLite (pymc3.backends.SQLite) -The NDArray and Text backend both hold the entire trace in memory, -whereas CSV and SQLite backends store the values while sampling. +The NDArray backend holds the entire trace in memory, whereas the Text +and SQLite backends store the values while sampling. Selecting a backend ------------------- @@ -107,16 +107,13 @@ If the traces are stored on disk, then a `load` function should also be defined that returns a MultiTrace object. -For specific examples, see pymc3.backends.{ndarray,text,csv,sqlite}.py. +For specific examples, see pymc3.backends.{ndarray,text,sqlite}.py. """ from ..backends.ndarray import NDArray from ..backends.text import Text -from ..backends.csv import CSV from ..backends.sqlite import SQLite _shortcuts = {'text': {'backend': Text, 'name': 'mcmc'}, - 'csv': {'backend': CSV, - 'name': 'mcmc'}, 'sqlite': {'backend': SQLite, 'name': 'mcmc.sqlite'}} diff --git a/pymc3/backends/csv.py b/pymc3/backends/csv.py deleted file mode 100644 index 95d9495a56..0000000000 --- a/pymc3/backends/csv.py +++ /dev/null @@ -1,248 +0,0 @@ -"""CSV file trace backend - -Store and retrieve sampling values from CSV file. - -CSV file format ---------------- - -Sampling values for each chain are saved in a separate file (under a -directory specified by the `name` argument). The rows correspond to -sampling iterations. The column names consist of variable names and -index labels. For example, the heading - - x,y__0_0,y__0_1,y__1_0,y__1_1,y__2_0,y__2_1 - -represents two variables, x and y, where x is a scalar and y has a -shape of (3, 2). -""" -from glob import glob -import numpy as np -import os -import pandas as pd -import warnings - -from ..backends import base - - -class CSV(base.BaseTrace): - """CSV trace object - - Parameters - ---------- - name : str - Name of directory to store CSV files in - model : Model - If None, the model is taken from the `with` context. - vars : list of variables - Sampling values will be stored for these variables. If None, - `model.unobserved_RVs` is used. - """ - def __init__(self, name, model=None, vars=None): - if not os.path.exists(name): - os.mkdir(name) - super(CSV, self).__init__(name, model, vars) - - self.flat_names = {v: _create_flat_names(v, shape) - for v, shape in self.var_shapes.items()} - - self.filename = None - self._fh = None - self.df = None - - ## Sampling methods - - def setup(self, draws, chain): - """Perform chain-specific setup. - - Parameters - ---------- - draws : int - Expected number of draws - chain : int - Chain number - """ - self.chain = chain - self.filename = os.path.join(self.name, 'chain-{}.csv'.format(chain)) - - cnames = [fv for v in self.varnames for fv in self.flat_names[v]] - - if os.path.exists(self.filename): - with open(self.filename) as fh: - prev_cnames = next(fh).strip().split(',') - if prev_cnames != cnames: - raise base.BackendError( - "Previous file '{}' has different variables names " - "than current model.".format(self.filename)) - self._fh = open(self.filename, 'a') - else: - self._fh = open(self.filename, 'w') - self._fh.write(','.join(cnames) + '\n') - - def record(self, point): - """Record results of a sampling iteration. - - Parameters - ---------- - point : dict - Values mapped to variable names - """ - vals = {} - for varname, value in zip(self.varnames, self.fn(point)): - vals[varname] = value.ravel() - columns = [str(val) for var in self.varnames for val in vals[var]] - self._fh.write(','.join(columns) + '\n') - - def close(self): - self._fh.close() - self._fh = None # Avoid serialization issue. - - ## Selection methods - - def _load_df(self): - if self.df is None: - self.df = pd.read_csv(self.filename) - - def __len__(self): - if self.filename is None: - return 0 - self._load_df() - return self.df.shape[0] - - def get_values(self, varname, burn=0, thin=1): - """Get values from trace. - - Parameters - ---------- - varname : str - burn : int - thin : int - - Returns - ------- - A NumPy array - """ - self._load_df() - var_df = self.df[self.flat_names[varname]] - shape = (self.df.shape[0],) + self.var_shapes[varname] - vals = var_df.values.ravel().reshape(shape) - return vals[burn::thin] - - def _slice(self, idx): - warnings.warn('Slice for CSV backend has no effect.') - - def point(self, idx): - """Return dictionary of point values at `idx` for current chain - with variables names as keys. - """ - idx = int(idx) - self._load_df() - pt = {} - for varname in self.varnames: - vals = self.df[self.flat_names[varname]].iloc[idx] - pt[varname] = vals.reshape(self.var_shapes[varname]) - return pt - - -def _create_flat_names(varname, shape): - """Return flat variable names for `varname` of `shape`. - - Examples - -------- - >>> _create_flat_names('x', (5,)) - ['x__0', 'x__1', 'x__2', 'x__3', 'x__4'] - - >>> _create_flat_names('x', (2, 2)) - ['x__0_0', 'x__0_1', 'x__1_0', 'x__1_1'] - """ - if not shape: - return [varname] - labels = (np.ravel(xs).tolist() for xs in np.indices(shape)) - labels = (map(str, xs) for xs in labels) - return ['{}__{}'.format(varname, '_'.join(idxs)) for idxs in zip(*labels)] - - -def _create_shape(flat_names): - "Determine shape from `_create_flat_names` output." - try: - _, shape_str = flat_names[-1].rsplit('__', 1) - except ValueError: - return () - return tuple(int(i) + 1 for i in shape_str.split('_')) - - -def load(name, model=None): - """Load CSV database. - - Parameters - ---------- - name : str - Name of directory that stores CSV files. - model : Model - If None, the model is taken from the `with` context. - - Returns - ------- - A MultiTrace instance - """ - files = glob(os.path.join(name, 'chain-*.csv')) - - traces = [] - for f in files: - chain = int(os.path.splitext(f)[0].rsplit('-', 1)[1]) - trace = CSV(name, model=model) - trace.chain = chain - trace.filename = f - traces.append(trace) - return base.MultiTrace(traces) - - -def dump(name, trace, chains=None): - """Store values from NDArray trace as CSV files. - - Parameters - ---------- - name : str - Name of directory to store CSV files in - trace : MultiTrace of NDArray traces - Result of MCMC run with default NDArray backend - chains : list - Chains to dump. If None, all chains are dumped. - """ - if not os.path.exists(name): - os.mkdir(name) - if chains is None: - chains = trace.chains - - var_shapes = trace._traces[chains[0]].var_shapes - flat_names = {v: _create_flat_names(v, shape) - for v, shape in var_shapes.items()} - - for chain in chains: - filename = os.path.join(name, 'chain-{}.csv'.format(chain)) - df = _trace_to_df(trace._traces[chain], flat_names) - df.to_csv(filename, index=False) - - -def _trace_to_df(trace, flat_names=None): - """Convert single-chain trace to Pandas DataFrame. - - Parameters - ---------- - trace : NDarray trace - flat_names : dict or None - A dictionary that maps each variable name in `trace` to a list - of flat variable names (e.g., ['x__0', 'x__1', ...]) - """ - if flat_names is None: - flat_names = {v: _create_flat_names(v, shape) - for v, shape in trace.var_shapes.items()} - - var_dfs = [] - for varname, shape in trace.var_shapes.items(): - vals = trace[varname] - if len(shape) == 1: - flat_vals = vals - else: - flat_vals = vals.reshape(len(trace), np.prod(shape)) - var_dfs.append(pd.DataFrame(flat_vals, columns=flat_names[varname])) - return pd.concat(var_dfs, axis=1) diff --git a/pymc3/backends/text.py b/pymc3/backends/text.py index 1084b45dcf..8055abe152 100644 --- a/pymc3/backends/text.py +++ b/pymc3/backends/text.py @@ -1,42 +1,31 @@ """Text file trace backend -After sampling with NDArray backend, save results as text files. +Store sampling values as CSV files. -As this other backends, this can be used by passing the backend instance -to `sample`. +File format +----------- - >>> import pymc3 as pm - >>> db = pm.backends.Text('test') - >>> trace = pm.sample(..., trace=db) +Sampling values for each chain are saved in a separate file (under a +directory specified by the `name` argument). The rows correspond to +sampling iterations. The column names consist of variable names and +index labels. For example, the heading -Or sampling can be performed with the default NDArray backend and then -dumped to text files after. + x,y__0_0,y__0_1,y__1_0,y__1_1,y__2_0,y__2_1 - >>> from pymc3.backends import text - >>> trace = pm.sample(...) - >>> text.dump('test', trace) - -Database format ---------------- - -For each chain, a directory named `chain-N` is created. In this -directory, one file per variable is created containing the values of the -object. To deal with multidimensional variables, the array is reshaped -to one dimension before saving with `numpy.savetxt`. The shape and dtype -information is saved in a json file in the same directory and is used to -load the database back again using `numpy.loadtxt`. +represents two variables, x and y, where x is a scalar and y has a +shape of (3, 2). """ -import os -import glob -import json +from glob import glob import numpy as np +import os +import pandas as pd +import warnings from ..backends import base -from ..backends.ndarray import NDArray -class Text(NDArray): - """Text storage +class Text(base.BaseTrace): + """Text trace object Parameters ---------- @@ -53,102 +42,207 @@ def __init__(self, name, model=None, vars=None): os.mkdir(name) super(Text, self).__init__(name, model, vars) - def close(self): - super(Text, self).close() - _dump_trace(self.name, self) - - -def dump(name, trace, chains=None): - """Store NDArray trace as text database. - - Parameters - ---------- - name : str - Name of directory to store text files - trace : MultiTrace of NDArray traces - Result of MCMC run with default NDArray backend - chains : list - Chains to dump. If None, all chains are dumped. - """ - if not os.path.exists(name): - os.mkdir(name) - if chains is None: - chains = trace.chains - for chain in chains: - _dump_trace(name, trace._traces[chain]) - + self.flat_names = {v: _create_flat_names(v, shape) + for v, shape in self.var_shapes.items()} + + self.filename = None + self._fh = None + self.df = None + + ## Sampling methods + + def setup(self, draws, chain): + """Perform chain-specific setup. + + Parameters + ---------- + draws : int + Expected number of draws + chain : int + Chain number + """ + self.chain = chain + self.filename = os.path.join(self.name, 'chain-{}.csv'.format(chain)) + + cnames = [fv for v in self.varnames for fv in self.flat_names[v]] + + if os.path.exists(self.filename): + with open(self.filename) as fh: + prev_cnames = next(fh).strip().split(',') + if prev_cnames != cnames: + raise base.BackendError( + "Previous file '{}' has different variables names " + "than current model.".format(self.filename)) + self._fh = open(self.filename, 'a') + else: + self._fh = open(self.filename, 'w') + self._fh.write(','.join(cnames) + '\n') + + def record(self, point): + """Record results of a sampling iteration. + + Parameters + ---------- + point : dict + Values mapped to variable names + """ + vals = {} + for varname, value in zip(self.varnames, self.fn(point)): + vals[varname] = value.ravel() + columns = [str(val) for var in self.varnames for val in vals[var]] + self._fh.write(','.join(columns) + '\n') -def _dump_trace(name, trace): - """Dump a single-chain trace. + def close(self): + self._fh.close() + self._fh = None # Avoid serialization issue. + + ## Selection methods + + def _load_df(self): + if self.df is None: + self.df = pd.read_csv(self.filename) + + def __len__(self): + if self.filename is None: + return 0 + self._load_df() + return self.df.shape[0] + + def get_values(self, varname, burn=0, thin=1): + """Get values from trace. + + Parameters + ---------- + varname : str + burn : int + thin : int + + Returns + ------- + A NumPy array + """ + self._load_df() + var_df = self.df[self.flat_names[varname]] + shape = (self.df.shape[0],) + self.var_shapes[varname] + vals = var_df.values.ravel().reshape(shape) + return vals[burn::thin] + + def _slice(self, idx): + warnings.warn('Slice for Text backend has no effect.') + + def point(self, idx): + """Return dictionary of point values at `idx` for current chain + with variables names as keys. + """ + idx = int(idx) + self._load_df() + pt = {} + for varname in self.varnames: + vals = self.df[self.flat_names[varname]].iloc[idx] + pt[varname] = vals.reshape(self.var_shapes[varname]) + return pt + + +def _create_flat_names(varname, shape): + """Return flat variable names for `varname` of `shape`. + + Examples + -------- + >>> _create_flat_names('x', (5,)) + ['x__0', 'x__1', 'x__2', 'x__3', 'x__4'] + + >>> _create_flat_names('x', (2, 2)) + ['x__0_0', 'x__0_1', 'x__1_0', 'x__1_1'] """ - chain_name = 'chain-{}'.format(trace.chain) - chain_dir = os.path.join(name, chain_name) - os.mkdir(chain_dir) + if not shape: + return [varname] + labels = (np.ravel(xs).tolist() for xs in np.indices(shape)) + labels = (map(str, xs) for xs in labels) + return ['{}__{}'.format(varname, '_'.join(idxs)) for idxs in zip(*labels)] - info = {} - for varname in trace.varnames: - data = trace.get_values(varname) - if np.issubdtype(data.dtype, np.int): - fmt = '%i' - is_int = True - else: - fmt = '%g' - is_int = False - info[varname] = {'shape': data.shape, 'is_int': is_int} +def _create_shape(flat_names): + "Determine shape from `_create_flat_names` output." + try: + _, shape_str = flat_names[-1].rsplit('__', 1) + except ValueError: + return () + return tuple(int(i) + 1 for i in shape_str.split('_')) - var_file = os.path.join(chain_dir, varname + '.txt') - np.savetxt(var_file, data.reshape(-1, data.size), fmt=fmt) - ## Store shape and dtype information for reloading. - info_file = os.path.join(chain_dir, 'info.json') - with open(info_file, 'w') as sfh: - json.dump(info, sfh) - -def load(name, chains=None, model=None): - """Load text database. +def load(name, model=None): + """Load Text database. Parameters ---------- name : str - Path to root directory for text database - chains : list - Chains to load. If None, all chains are loaded. + Name of directory with files (one per chain) model : Model If None, the model is taken from the `with` context. Returns ------- - ndarray.Trace instance + A MultiTrace instance """ - chain_dirs = _get_chain_dirs(name) - if chains is None: - chains = list(chain_dirs.keys()) + files = glob(os.path.join(name, 'chain-*.csv')) traces = [] - for chain in chains: - chain_dir = chain_dirs[chain] - info_file = os.path.join(chain_dir, 'info.json') - with open(info_file, 'r') as sfh: - info = json.load(sfh) - samples = {} - for varname, info in info.items(): - var_file = os.path.join(chain_dir, varname + '.txt') - dtype = int if info['is_int'] else float - flat_data = np.loadtxt(var_file, dtype=dtype) - samples[varname] = flat_data.reshape(info['shape']) - trace = NDArray(model=model) - trace.samples = samples + for f in files: + chain = int(os.path.splitext(f)[0].rsplit('-', 1)[1]) + trace = Text(name, model=model) trace.chain = chain + trace.filename = f traces.append(trace) return base.MultiTrace(traces) -def _get_chain_dirs(name): - """Return mapping of chain number to directory.""" - return {_chain_dir_to_chain(chain_dir): chain_dir - for chain_dir in glob.glob(os.path.join(name, 'chain-*'))} +def dump(name, trace, chains=None): + """Store values from NDArray trace as CSV files. + + Parameters + ---------- + name : str + Name of directory to store CSV files in + trace : MultiTrace of NDArray traces + Result of MCMC run with default NDArray backend + chains : list + Chains to dump. If None, all chains are dumped. + """ + if not os.path.exists(name): + os.mkdir(name) + if chains is None: + chains = trace.chains + + var_shapes = trace._traces[chains[0]].var_shapes + flat_names = {v: _create_flat_names(v, shape) + for v, shape in var_shapes.items()} + + for chain in chains: + filename = os.path.join(name, 'chain-{}.csv'.format(chain)) + df = _trace_to_df(trace._traces[chain], flat_names) + df.to_csv(filename, index=False) + +def _trace_to_df(trace, flat_names=None): + """Convert single-chain trace to Pandas DataFrame. -def _chain_dir_to_chain(chain_dir): - return int(os.path.basename(chain_dir).split('-')[1]) + Parameters + ---------- + trace : NDarray trace + flat_names : dict or None + A dictionary that maps each variable name in `trace` to a list + of flat variable names (e.g., ['x__0', 'x__1', ...]) + """ + if flat_names is None: + flat_names = {v: _create_flat_names(v, shape) + for v, shape in trace.var_shapes.items()} + + var_dfs = [] + for varname, shape in trace.var_shapes.items(): + vals = trace[varname] + if len(shape) == 1: + flat_vals = vals + else: + flat_vals = vals.reshape(len(trace), np.prod(shape)) + var_dfs.append(pd.DataFrame(flat_vals, columns=flat_names[varname])) + return pd.concat(var_dfs, axis=1) diff --git a/pymc3/tests/test_csv_backend.py b/pymc3/tests/test_csv_backend.py deleted file mode 100644 index 4cbce6a6a7..0000000000 --- a/pymc3/tests/test_csv_backend.py +++ /dev/null @@ -1,121 +0,0 @@ -import numpy.testing as npt -from pymc3.tests import backend_fixtures as bf -from pymc3.backends import ndarray, csv - - -class TestCSV0dSampling(bf.SamplingTestCase): - backend = csv.CSV - name = 'csv-db' - shape = () - - -class TestCSV1dSampling(bf.SamplingTestCase): - backend = csv.CSV - name = 'csv-db' - shape = 2 - - -class TestCSV2dSampling(bf.SamplingTestCase): - backend = csv.CSV - name = 'csv-db' - shape = (2, 3) - - -class TestCSV0dSelection(bf.SelectionNoSliceTestCase): - backend = csv.CSV - name = 'csv-db' - shape = () - - -class TestCSV1dSelection(bf.SelectionNoSliceTestCase): - backend = csv.CSV - name = 'csv-db' - shape = 2 - - -class TestCSV2dSelection(bf.SelectionNoSliceTestCase): - backend = csv.CSV - name = 'csv-db' - shape = (2, 3) - - -class TestCSVDumpLoad(bf.DumpLoadTestCase): - backend = csv.CSV - load_func = staticmethod(csv.load) - name = 'csv-db' - shape = (2, 3) - - -class TestCSVDumpFunction(bf.BackendEqualityTestCase): - backend0 = backend1 = ndarray.NDArray - name0 = None - name1 = 'csv-db' - shape = (2, 3) - - @classmethod - def setUpClass(cls): - super(TestCSVDumpFunction, cls).setUpClass() - csv.dump(cls.name1, cls.mtrace1) - with cls.model: - cls.mtrace1 = csv.load(cls.name1) - - -class TestTraceToDf(bf.ModelBackendSampledTestCase): - backend = ndarray.NDArray - name = 'csv-db' - shape = (2, 3) - - def test_trace_to_df(self): - mtrace = self.mtrace - df = csv._trace_to_df(mtrace._traces[0]) - self.assertEqual(len(mtrace), df.shape[0]) - - checked = False - for varname in self.test_point.keys(): - vararr = mtrace.get_values(varname, chains=0) - ## With `shape` above, only one variable has to have that - ## `shape`. - if vararr.shape[1:] != self.shape: - continue - npt.assert_equal(vararr[:, 0, 0], df[varname + '__0_0'].values) - npt.assert_equal(vararr[:, 1, 0], df[varname + '__1_0'].values) - npt.assert_equal(vararr[:, 1, 2], df[varname + '__1_2'].values) - checked = True - self.assertTrue(checked) - -class TestNDArrayCSVEquality(bf.BackendEqualityTestCase): - backend0 = ndarray.NDArray - name0 = None - backend1 = csv.CSV - name1 = 'csv-db' - shape = (2, 3) - - -def test_create_flat_names_0d(): - shape = () - result = csv._create_flat_names('x', shape) - expected = ['x'] - assert result == expected - assert csv._create_shape(result) == shape - - -def test_create_flat_names_1d(): - shape = 2, - result = csv._create_flat_names('x', shape) - expected = ['x__0', 'x__1'] - assert result == expected - assert csv._create_shape(result) == shape - - -def test_create_flat_names_2d(): - shape = 2, 3 - result = csv._create_flat_names('x', shape) - expected = ['x__0_0', 'x__0_1', 'x__0_2', - 'x__1_0', 'x__1_1', 'x__1_2'] - assert result == expected - assert csv._create_shape(result) == shape - - -def test_create_flat_names_3d(): - shape = 2, 3, 4 - assert csv._create_shape(csv._create_flat_names('x', shape)) == shape diff --git a/pymc3/tests/test_text_backend.py b/pymc3/tests/test_text_backend.py index 263f9bec37..51181cafec 100644 --- a/pymc3/tests/test_text_backend.py +++ b/pymc3/tests/test_text_backend.py @@ -3,6 +3,42 @@ from pymc3.backends import ndarray, text +class TestText0dSampling(bf.SamplingTestCase): + backend = text.Text + name = 'text-db' + shape = () + + +class TestText1dSampling(bf.SamplingTestCase): + backend = text.Text + name = 'text-db' + shape = 2 + + +class TestText2dSampling(bf.SamplingTestCase): + backend = text.Text + name = 'text-db' + shape = (2, 3) + + +class TestText0dSelection(bf.SelectionNoSliceTestCase): + backend = text.Text + name = 'text-db' + shape = () + + +class TestText1dSelection(bf.SelectionNoSliceTestCase): + backend = text.Text + name = 'text-db' + shape = 2 + + +class TestText2dSelection(bf.SelectionNoSliceTestCase): + backend = text.Text + name = 'text-db' + shape = (2, 3) + + class TestTextDumpLoad(bf.DumpLoadTestCase): backend = text.Text load_func = staticmethod(text.load) @@ -24,6 +60,62 @@ def setUpClass(cls): cls.mtrace1 = text.load(cls.name1) -def test__chain_dir_to_chain(): - assert text._chain_dir_to_chain('/path/to/chain-0') == 0 - assert text._chain_dir_to_chain('chain-0') == 0 +class TestTraceToDf(bf.ModelBackendSampledTestCase): + backend = ndarray.NDArray + name = 'text-db' + shape = (2, 3) + + def test_trace_to_df(self): + mtrace = self.mtrace + df = text._trace_to_df(mtrace._traces[0]) + self.assertEqual(len(mtrace), df.shape[0]) + + checked = False + for varname in self.test_point.keys(): + vararr = mtrace.get_values(varname, chains=0) + ## With `shape` above, only one variable has to have that + ## `shape`. + if vararr.shape[1:] != self.shape: + continue + npt.assert_equal(vararr[:, 0, 0], df[varname + '__0_0'].values) + npt.assert_equal(vararr[:, 1, 0], df[varname + '__1_0'].values) + npt.assert_equal(vararr[:, 1, 2], df[varname + '__1_2'].values) + checked = True + self.assertTrue(checked) + +class TestNDArrayTextEquality(bf.BackendEqualityTestCase): + backend0 = ndarray.NDArray + name0 = None + backend1 = text.Text + name1 = 'text-db' + shape = (2, 3) + + +def test_create_flat_names_0d(): + shape = () + result = text._create_flat_names('x', shape) + expected = ['x'] + assert result == expected + assert text._create_shape(result) == shape + + +def test_create_flat_names_1d(): + shape = 2, + result = text._create_flat_names('x', shape) + expected = ['x__0', 'x__1'] + assert result == expected + assert text._create_shape(result) == shape + + +def test_create_flat_names_2d(): + shape = 2, 3 + result = text._create_flat_names('x', shape) + expected = ['x__0_0', 'x__0_1', 'x__0_2', + 'x__1_0', 'x__1_1', 'x__1_2'] + assert result == expected + assert text._create_shape(result) == shape + + +def test_create_flat_names_3d(): + shape = 2, 3, 4 + assert text._create_shape(text._create_flat_names('x', shape)) == shape From 7f83801311ac9eef1de6b195b83235b433b9d0fc Mon Sep 17 00:00:00 2001 From: Kyle Meyer Date: Sat, 6 Jun 2015 00:49:04 -0400 Subject: [PATCH 04/24] test_sqlite_backend.py: Don't hardcode /tmp Commit 85b53d4c08 changed the location of the test sqlite file from the PWD to /tmp. (I believe this was because, due to permission issues, the file was not being removed, and subsequent tests were failing as a result). Use tempfile.gettempdir to be more portable. --- pymc3/tests/test_sqlite_backend.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/pymc3/tests/test_sqlite_backend.py b/pymc3/tests/test_sqlite_backend.py index a7ab5c2678..a4862d90a1 100644 --- a/pymc3/tests/test_sqlite_backend.py +++ b/pymc3/tests/test_sqlite_backend.py @@ -1,48 +1,52 @@ import numpy.testing as npt +import os from pymc3.tests import backend_fixtures as bf from pymc3.backends import ndarray, sqlite +import tempfile + +DBNAME = os.path.join(tempfile.gettempdir(), 'test.db') class TestSQlite0dSampling(bf.SamplingTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = () class TestSQlite1dSampling(bf.SamplingTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = 2 class TestSQlite2dSampling(bf.SamplingTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = (2, 3) class TestSQLite0dSelection(bf.SelectionNoSliceTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = () class TestSQLite1dSelection(bf.SelectionNoSliceTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = 2 class TestSQLite2dSelection(bf.SelectionNoSliceTestCase): backend = sqlite.SQLite - name = '/tmp/test.db' + name = DBNAME shape = (2, 3) class TestSQLiteDumpLoad(bf.DumpLoadTestCase): backend = sqlite.SQLite load_func = staticmethod(sqlite.load) - name = '/tmp/test.db' + name = DBNAME shape = (2, 3) @@ -50,7 +54,7 @@ class TestNDArraySqliteEquality(bf.BackendEqualityTestCase): backend0 = ndarray.NDArray name0 = None backend1 = sqlite.SQLite - name1 = '/tmp/test.db' + name1 = DBNAME shape = (2, 3) From 2722583a815a6d62c8ea6ed4ca09729a61cec8e7 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Sun, 24 May 2015 01:06:08 -0700 Subject: [PATCH 05/24] simple draft of missing values --- pymc3/examples/disaster_model.ipynb | 135 ++++++++++++++++++++++++++++ pymc3/model.py | 47 +++++++--- 2 files changed, 171 insertions(+), 11 deletions(-) create mode 100644 pymc3/examples/disaster_model.ipynb diff --git a/pymc3/examples/disaster_model.ipynb b/pymc3/examples/disaster_model.ipynb new file mode 100644 index 0000000000..191abcd407 --- /dev/null +++ b/pymc3/examples/disaster_model.ipynb @@ -0,0 +1,135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [-----------------100%-----------------] 1000 of 1000 complete in 10.9 sec" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":0: FutureWarning: IPython widgets are experimental and may change in the future.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAI5CAYAAABTgvDdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWFwwpSVyDFUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\"\"\"\n", + "A model for coal mining disasters data with a changepoint\n", + "\n", + "switchpoint ~ U(0, 110)\n", + "early_mean ~ Exp(1.)\n", + "late_mean ~ Exp(1.)\n", + "disasters[t] ~ Po(early_mean if t <= switchpoint, late_mean otherwise)\n", + "\n", + "\"\"\"\n", + "\n", + "from pymc3 import *\n", + "\n", + "import theano.tensor as t\n", + "from numpy import arange, array, ones, concatenate\n", + "from numpy.random import randint\n", + "from numpy.ma import masked_values\n", + "\n", + "__all__ = ['disasters_data', 'switchpoint', 'early_mean', 'late_mean', 'rate',\n", + " 'disasters']\n", + "\n", + "# Time series of recorded coal mining disasters in the UK from 1851 to 1962\n", + "disasters_data = masked_values([4, 5, 4, 0, 1, 4, 3, 4, 0, -1, 3, 3, 4, 0, 2, 6,\n", + " 3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5,\n", + " 2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0,\n", + " 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 2,\n", + " 3, 3, 1, 1, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4,\n", + " 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1], value=-1)\n", + "years = len(disasters_data)\n", + "\n", + "with Model() as model:\n", + "\n", + " # Prior for distribution of switchpoint location\n", + " switchpoint = DiscreteUniform('switchpoint', lower=0, upper=years)\n", + " # Priors for pre- and post-switch mean number of disasters\n", + " early_mean = Exponential('early_mean', lam=1.)\n", + " late_mean = Exponential('late_mean', lam=1.)\n", + "\n", + " # Allocate appropriate Poisson rates to years before and after current\n", + " # switchpoint location\n", + " idx = arange(years)\n", + " rate = switch(switchpoint >= idx, early_mean, late_mean)\n", + "\n", + " # Data likelihood\n", + " disasters = Poisson('disasters', rate, observed=disasters_data)\n", + "\n", + "\n", + "def run(n=1000):\n", + " if n == \"short\":\n", + " n = 50\n", + " with model:\n", + "\n", + " # Initial values for stochastic nodes\n", + " start = {'early_mean': 2., 'late_mean': 3.}\n", + "\n", + " # Use slice sampler for means\n", + " step1 = Slice([early_mean, late_mean])\n", + " # Use Metropolis for switchpoint, since it accomodates discrete variables\n", + " step2 = Metropolis([switchpoint] +model.missing_values)\n", + "\n", + " tr = sample(n, tune=500, start=start, step=[step1, step2])\n", + " traceplot(tr)\n", + "\n", + "if __name__ == '__main__':\n", + " run()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/pymc3/model.py b/pymc3/model.py index f59c368354..db1bd25f6d 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -90,6 +90,7 @@ def __init__(self): self.observed_RVs = [] self.deterministics = [] self.potentials = [] + self.missing_values = [] self.model = self @property @@ -101,8 +102,8 @@ def logpt(self): @property def vars(self): - """List of unobserved random variables the model is defined in terms of (which excludes deterministics).""" - return self.free_RVs + """List of unobserved random variables used as inputs to the model (which excludes deterministics).""" + return self.free_RVs + self.missing_values @property def basic_RVs(self): @@ -112,7 +113,7 @@ def basic_RVs(self): @property def unobserved_RVs(self): """List of all random variable, including deterministic ones.""" - return self.free_RVs + self.deterministics + return self.vars + self.deterministics @property @@ -150,6 +151,8 @@ def Var(self, name, dist, data=None): else: var = ObservedRV(name=name, data=data, distribution=dist, model=self) self.observed_RVs.append(var) + self.missing_values += var.missing_values + self.add_random_variable(var) return var @@ -342,8 +345,28 @@ def __init__(self, type=None, owner=None, index=None, name=None, distribution=No self.logp_elemwiset = distribution.logp(self) self.model = model +def as_tensor(data, name): + if getattr(data, 'mask', None) is None: + return t.constant(data, name=name) + + else: + type = t.TensorType(str(data.dtype), (False,)) + free = TensorVariable(type, owner=None, index=None, name=name + '_missing') + #this stuff needs to be made generic with FreeRV + free.tag.test_value = np.full(data.mask.sum(), data.mean(), dtype=data.dtype) + free.dshape = (data.mask.sum(),) + free.dsize = data.mask.sum() + + constant = t.constant(data.filled()) + + dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], free) + dataTensor.unobserved = free + return dataTensor + class ObservedRV(Factor): - """Observed random variable that a model is specified in terms of.""" + """Observed random variable that a model is specified in terms of. + Potentially partially observed. + """ def __init__(self, name, data, distribution, model): """ Parameters @@ -358,16 +381,18 @@ def __init__(self, name, data, distribution, model): """ self.name = name data = getattr(data, 'values', data) #handle pandas - args = as_iterargs(data) + data_arrays = as_iterargs(data) - if len(args) > 1: - params = getargspec(distribution.logp).args - args = [t.as_tensor_variable(d, name=name + "_" + param) - for d,param in zip(args,params) ] + if len(data_arrays) > 1: + names = [name + "_" + param for param in getargspec(distribution.logp).args] else: - args = [t.as_tensor_variable(args[0], name=name)] + names = [name] + + data_arrays = [as_tensor(data, name) for data, name in zip(data_arrays,names)] + self.data = data_arrays + self.missing_values = [d.unobserved for d in data_arrays if hasattr(d, 'unobserved')] - self.logp_elemwiset = distribution.logp(*args) + self.logp_elemwiset = distribution.logp(*data_arrays) self.model = model self.distribution = distribution From f1961911026144408f83aa84250f13e59b890d1e Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Sun, 24 May 2015 19:36:49 -0700 Subject: [PATCH 06/24] missing vals use NoDistribution --- pymc3/distributions/distribution.py | 6 +++++- pymc3/model.py | 18 ++++++++---------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/pymc3/distributions/distribution.py b/pymc3/distributions/distribution.py index 47e8f73ead..003b0bd9fa 100644 --- a/pymc3/distributions/distribution.py +++ b/pymc3/distributions/distribution.py @@ -2,7 +2,7 @@ import numpy as np from ..model import Model -__all__ = ['DensityDist', 'Distribution', 'Continuous', 'Discrete'] +__all__ = ['DensityDist', 'Distribution', 'Continuous', 'Discrete', 'NoDistribution'] class Distribution(object): @@ -69,6 +69,10 @@ def getattr_value(self, val): def TensorType(dtype, shape): return t.TensorType(str(dtype), np.atleast_1d(shape) == 1) +class NoDistribution(Distribution): + def logp(self, x): + return 0 + class Discrete(Distribution): """Base class for discrete distributions""" def __init__(self, shape=(), dtype='int64', defaults=['mode'], *args, **kwargs): diff --git a/pymc3/model.py b/pymc3/model.py index db1bd25f6d..bb95cd851f 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -103,7 +103,7 @@ def logpt(self): @property def vars(self): """List of unobserved random variables used as inputs to the model (which excludes deterministics).""" - return self.free_RVs + self.missing_values + return self.free_RVs @property def basic_RVs(self): @@ -151,6 +151,7 @@ def Var(self, name, dist, data=None): else: var = ObservedRV(name=name, data=data, distribution=dist, model=self) self.observed_RVs.append(var) + self.free_RVs += var.missing_values self.missing_values += var.missing_values self.add_random_variable(var) @@ -350,17 +351,14 @@ def as_tensor(data, name): return t.constant(data, name=name) else: - type = t.TensorType(str(data.dtype), (False,)) - free = TensorVariable(type, owner=None, index=None, name=name + '_missing') - #this stuff needs to be made generic with FreeRV - free.tag.test_value = np.full(data.mask.sum(), data.mean(), dtype=data.dtype) - free.dshape = (data.mask.sum(),) - free.dsize = data.mask.sum() + from distributions import NoDistribution + fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=data.dtype, testval=data.mask.mean().astype(data.dtype)) + missing_values = FreeRV(name=name + '_missing', distribution=fakedist) constant = t.constant(data.filled()) - dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], free) - dataTensor.unobserved = free + dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], missing_values) + dataTensor.missing_values = missing_values return dataTensor class ObservedRV(Factor): @@ -390,7 +388,7 @@ def __init__(self, name, data, distribution, model): data_arrays = [as_tensor(data, name) for data, name in zip(data_arrays,names)] self.data = data_arrays - self.missing_values = [d.unobserved for d in data_arrays if hasattr(d, 'unobserved')] + self.missing_values = [d.missing_values for d in data_arrays if hasattr(d, 'missing_values')] self.logp_elemwiset = distribution.logp(*data_arrays) self.model = model From 7959bede80d8b718889a37be4d93a7622cfaf772 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Sun, 24 May 2015 23:37:51 -0700 Subject: [PATCH 07/24] test missing values --- pymc3/tests/test_missing.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 pymc3/tests/test_missing.py diff --git a/pymc3/tests/test_missing.py b/pymc3/tests/test_missing.py new file mode 100644 index 0000000000..067052d578 --- /dev/null +++ b/pymc3/tests/test_missing.py @@ -0,0 +1,15 @@ +from pymc3 import Model, Normal, Metropolis, MvNormal +from numpy import ma + +def test_missing(): + data = ma.masked_values([1,2,-1,4,-1], value=-1) + with Model() as model: + x = Normal('x', 1, 1) + y = Normal('y', x, 1, observed=data) + + y_missing, = model.missing_values + assert y_missing.tag.test_value.shape == (2,) + + model.logp(model.test_point) + + From 875d45f933c641bfc6e245b5e3fcd45916e2ce24 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Mon, 25 May 2015 00:50:17 -0700 Subject: [PATCH 08/24] fix for python 3.4 --- pymc3/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymc3/model.py b/pymc3/model.py index bb95cd851f..64229b479a 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -351,7 +351,7 @@ def as_tensor(data, name): return t.constant(data, name=name) else: - from distributions import NoDistribution + from .distributions import NoDistribution fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=data.dtype, testval=data.mask.mean().astype(data.dtype)) missing_values = FreeRV(name=name + '_missing', distribution=fakedist) From 0082eefdcfbfc5d28450f2cea6c71d7bf1e38bed Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Mon, 25 May 2015 13:18:57 -0700 Subject: [PATCH 09/24] handle missing data from pandas --- pymc3/model.py | 22 +++++++++++++++------- pymc3/tests/test_missing.py | 12 ++++++++++++ 2 files changed, 27 insertions(+), 7 deletions(-) diff --git a/pymc3/model.py b/pymc3/model.py index 64229b479a..ae562d2829 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -346,20 +346,31 @@ def __init__(self, type=None, owner=None, index=None, name=None, distribution=No self.logp_elemwiset = distribution.logp(self) self.model = model +def pandas_to_array(data): + if hasattr(data, 'values'): #pandas + if data.isnull().any().any(): #missing values + return np.ma.MaskedArray(data.values, data.isnull().values) + else: + return data.values + else: + return data + + def as_tensor(data, name): - if getattr(data, 'mask', None) is None: - return t.constant(data, name=name) + data = pandas_to_array(data) - else: + if hasattr(data, 'mask'): from .distributions import NoDistribution fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=data.dtype, testval=data.mask.mean().astype(data.dtype)) missing_values = FreeRV(name=name + '_missing', distribution=fakedist) - constant = t.constant(data.filled()) + constant = t.as_tensor_variable(data.filled()) dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], missing_values) dataTensor.missing_values = missing_values return dataTensor + else: + return t.as_tensor_variable(data, name=name) class ObservedRV(Factor): """Observed random variable that a model is specified in terms of. @@ -378,7 +389,6 @@ def __init__(self, name, data, distribution, model): model : Model """ self.name = name - data = getattr(data, 'values', data) #handle pandas data_arrays = as_iterargs(data) if len(data_arrays) > 1: @@ -456,8 +466,6 @@ def __init__(self, type=None, owner=None, index=None, name=None, distribution=No def as_iterargs(data): if isinstance(data, tuple): return data - if hasattr(data, 'columns'): # data frames - return [np.asarray(data[c]) for c in data.columns] else: return [data] diff --git a/pymc3/tests/test_missing.py b/pymc3/tests/test_missing.py index 067052d578..dfbd27088b 100644 --- a/pymc3/tests/test_missing.py +++ b/pymc3/tests/test_missing.py @@ -1,5 +1,7 @@ from pymc3 import Model, Normal, Metropolis, MvNormal from numpy import ma +import numpy +import pandas as pd def test_missing(): data = ma.masked_values([1,2,-1,4,-1], value=-1) @@ -13,3 +15,13 @@ def test_missing(): model.logp(model.test_point) +def test_missing_pandas(): + data = pd.DataFrame([1,2,numpy.nan,4,numpy.nan]) + with Model() as model: + x = Normal('x', 1, 1) + y = Normal('y', x, 1, observed=data) + + y_missing, = model.missing_values + assert y_missing.tag.test_value.shape == (2,) + + model.logp(model.test_point) From 92c9e01cb25ed95308885fdd58f553dcfaf3c383 Mon Sep 17 00:00:00 2001 From: Chris Fonnesbeck Date: Wed, 27 May 2015 16:03:32 -0500 Subject: [PATCH 10/24] Added disaster_model_missing (not working) --- pymc3/examples/disaster_model_missing.py | 68 ++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 pymc3/examples/disaster_model_missing.py diff --git a/pymc3/examples/disaster_model_missing.py b/pymc3/examples/disaster_model_missing.py new file mode 100644 index 0000000000..359dc9dd6d --- /dev/null +++ b/pymc3/examples/disaster_model_missing.py @@ -0,0 +1,68 @@ +""" +A model for coal mining disasters data with a changepoint + +switchpoint ~ U(0, 110) +early_mean ~ Exp(1.) +late_mean ~ Exp(1.) +disasters[t] ~ Po(early_mean if t <= switchpoint, late_mean otherwise) + +""" + +from pymc3 import * + +import theano.tensor as t +from numpy import arange, array, ones, concatenate +from numpy.random import randint +from numpy.ma import masked_values + +__all__ = ['disasters_data', 'switchpoint', 'early_mean', 'late_mean', 'rate', + 'disasters'] + +# Time series of recorded coal mining disasters in the UK from 1851 to 1962 +disasters_data = array([4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6, + 3, 3, 5, 4, 5, 3, 1, -1, 4, 1, 5, 5, 3, 4, 2, 5, + 2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0, + 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1, + 0, 1, 0, 1, -1, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2, + 3, 3, 1, 1, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4, + 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]) +years = len(disasters_data) + +masked_values = masked_values(disasters_data, value=-1) + +with Model() as model: + + # Prior for distribution of switchpoint location + switchpoint = DiscreteUniform('switchpoint', lower=0, upper=years) + # Priors for pre- and post-switch mean number of disasters + early_mean = Exponential('early_mean', lam=1.) + late_mean = Exponential('late_mean', lam=1.) + + # Allocate appropriate Poisson rates to years before and after current + # switchpoint location + idx = arange(years) + rate = switch(switchpoint >= idx, early_mean, late_mean) + + # Data likelihood + disasters = Poisson('disasters', rate, observed=masked_values) + + +def run(n=1000): + if n == "short": + n = 50 + with model: + + # Initial values for stochastic nodes + start = {'early_mean': 2., 'late_mean': 3.} + + # Use slice sampler for means + step1 = Slice([early_mean, late_mean]) + # Use Metropolis for switchpoint, since it accomodates discrete variables + step2 = Metropolis([switchpoint]) + + tr = sample(n, tune=500, start=start, step=[step1, step2]) + + summary(tr, vars=['disasters_missing']) + +if __name__ == '__main__': + run() From 6111b9580adb72b5009aa02aa936d27ba379432f Mon Sep 17 00:00:00 2001 From: Chris Fonnesbeck Date: Thu, 28 May 2015 17:10:34 -0500 Subject: [PATCH 11/24] Added lasso model with missing covariates --- pymc3/examples/lasso_missing.py | 52 +++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 pymc3/examples/lasso_missing.py diff --git a/pymc3/examples/lasso_missing.py b/pymc3/examples/lasso_missing.py new file mode 100644 index 0000000000..1aba42e54b --- /dev/null +++ b/pymc3/examples/lasso_missing.py @@ -0,0 +1,52 @@ +from pymc3 import * +import numpy as np +import pandas as pd +from numpy.ma import masked_values + +# Import data, filling missing values with sentinels (-999) +test_scores = pd.read_csv(get_data_file('pymc3.examples', 'data/test_scores.csv')).fillna(-999) + +# Extract variables: test score, gender, number of siblings, previous disability, age, +# mother with HS education or better, hearing loss identified by 3 months of age +(score, male, siblings, disability, + age, mother_hs, early_ident) = test_scores[['score', 'male', 'sib', + 'synd_or_disab', 'age_test', + 'mother_hs', 'ident_by_3']].astype(float).values.T + +with Model() as model: + + # Impute missing values + sib_mean = Exponential('sib_mean', 1) + siblings_imp = Poisson('siblings_imp', sib_mean, observed=masked_values(siblings, value=-999)) + + p_disab = Beta('p_disab', 1, 1) + disability_imp = Bernoulli('disability_imp', p_disab, observed=masked_values(disability, value=-999)) + + p_mother = Beta('p_mother', 1, 1) + mother_imp = Bernoulli('mother_imp', p_mother, observed=masked_values(mother_hs, value=-999)) + + s = HalfCauchy('s', 5) + beta = Laplace('beta', 0, 100, shape=7) + + p = (beta[0] + beta[1]*male + beta[2]*siblings_imp + beta[3]*disability_imp + + beta[4]*age + beta[5]*mother_imp + beta[6]*early_ident) + + observed_score = Normal('observed_score', expected_score, s ** -2, observed=score) + + +with model: + step1 = NUTS([beta, s, p_disab, p_mother, sib_mean]) + + step2 = Metropolis([mother_imp.missing_values, + disability_imp.missing_values, + siblings_imp.missing_values]) + +def run(n=5000): + + with model: + start = find_MAP() + trace = sample(n, [step1, step2], start) + + +if __name__ == '__main__': + run() From ce97cb701aa0eb96dede07e03c04bea245deeb36 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Tue, 2 Jun 2015 11:22:52 -0700 Subject: [PATCH 12/24] split observedrv into observedrv and multiobserved With the introduction of missing variables it becomes important to be able to use the value of an ObservedRV. However, this was not possible because ObservedRV didn't subclass TensorVariable because ObservedRV could also handle multiple observed arrays so wouldn't always be a single tensor. This splits up the two cases into ObservedRV, for single observed arrays, and MultiObservedRV for multiple observed arrays. ObservedRV now inherits from TensorVariable. --- pymc3/model.py | 46 ++++++++++++++++++++++++++++++++++++++-------- pymc3/theanof.py | 30 +++++++++++++++++++++++++++++- 2 files changed, 67 insertions(+), 9 deletions(-) diff --git a/pymc3/model.py b/pymc3/model.py index ae562d2829..b601812c99 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -148,11 +148,16 @@ def Var(self, name, dist, data=None): var = TransformedRV(name=name, distribution=dist, model=self, transform=dist.transform) self.deterministics.append(var) return var - else: - var = ObservedRV(name=name, data=data, distribution=dist, model=self) + elif isinstance(data, dict): + var = MultiObservedRV(name=name, data=data, distribution=dist, model=self) self.observed_RVs.append(var) self.free_RVs += var.missing_values self.missing_values += var.missing_values + else: + var = ObservedRV(name=name, data=data, distribution=dist, model=self) + self.observed_RVs.append(var) + self.free_RVs.append(var.missing_values) + self.missing_values.append(var.missing_values) self.add_random_variable(var) return var @@ -367,12 +372,37 @@ def as_tensor(data, name): constant = t.as_tensor_variable(data.filled()) dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], missing_values) - dataTensor.missing_values = missing_values - return dataTensor + return dataTensor, missing_values else: - return t.as_tensor_variable(data, name=name) + return t.as_tensor_variable(data, name=name), None + +class ObservedRV(Factor, TensorVariable): + """Observed random variable that a model is specified in terms of. + Potentially partially observed. + """ + def __init__(self, name, data, distribution, model): + """ + Parameters + ---------- + + type : theano type (optional) + owner : theano owner (optional) + + name : str + distribution : Distribution + model : Model + """ + super(TensorVariable, self).__init__(distribution.type, None, None, name) + + data, self.missing_values = as_tensor(data) + + self.logp_elemwiset = distribution.logp(data) + self.model = model + self.distribution = distribution + + theano.gof.Apply(identity, inputs=[data], outputs=[self]) -class ObservedRV(Factor): +class MultiObservedRV(Factor): """Observed random variable that a model is specified in terms of. Potentially partially observed. """ @@ -397,8 +427,8 @@ def __init__(self, name, data, distribution, model): names = [name] data_arrays = [as_tensor(data, name) for data, name in zip(data_arrays,names)] - self.data = data_arrays - self.missing_values = [d.missing_values for d in data_arrays if hasattr(d, 'missing_values')] + self.data = [d for d, missing in data_arrays] + self.missing_values = [missing for d, missing in data_arrays if missing is not None] self.logp_elemwiset = distribution.logp(*data_arrays) self.model = model diff --git a/pymc3/theanof.py b/pymc3/theanof.py index 69963b3ff2..2bd89adb34 100644 --- a/pymc3/theanof.py +++ b/pymc3/theanof.py @@ -1,5 +1,5 @@ from .vartypes import typefilter, continuous_types -from theano import theano, tensor as t +from theano import theano, scalar, tensor as t from theano.gof.graph import inputs from .memoize import memoize @@ -99,3 +99,31 @@ def makeiter(a): return a else: return [a] + + +class IdentityOp(scalar.UnaryScalarOp): + @staticmethod + def st_impl(x): + return x + + def impl(self, x): + return x + + def grad(self, inp, grads): + x, = inp + gz, = grads + return grads + + def c_code(self, node, name, inp, out, sub): + x, = inp + z, = out + return """%(z)s = %(x)s;""" % locals() + + def __eq__(self, other): + return type(self) == type(other) + + def __hash__(self): + return hash(type(self)) + +scalar_identity = IdentityOp(scalar.upgrade_to_float, name='scalar_identity') +identity = tensor.Elemwise(scalar_identity, name='identity') From 7aee153ef6b0bad481aed8031c977c218c9e4ec4 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Tue, 2 Jun 2015 14:43:37 -0700 Subject: [PATCH 13/24] make example work --- pymc3/distributions/distribution.py | 2 +- pymc3/examples/disaster_model.ipynb | 112 ++++++++++++++++++++++------ pymc3/model.py | 22 ++++-- pymc3/theanof.py | 2 +- 4 files changed, 105 insertions(+), 33 deletions(-) diff --git a/pymc3/distributions/distribution.py b/pymc3/distributions/distribution.py index 003b0bd9fa..dd68d48a1f 100644 --- a/pymc3/distributions/distribution.py +++ b/pymc3/distributions/distribution.py @@ -2,7 +2,7 @@ import numpy as np from ..model import Model -__all__ = ['DensityDist', 'Distribution', 'Continuous', 'Discrete', 'NoDistribution'] +__all__ = ['DensityDist', 'Distribution', 'Continuous', 'Discrete', 'NoDistribution', 'TensorType'] class Distribution(object): diff --git a/pymc3/examples/disaster_model.ipynb b/pymc3/examples/disaster_model.ipynb index 191abcd407..8687f5ac24 100644 --- a/pymc3/examples/disaster_model.ipynb +++ b/pymc3/examples/disaster_model.ipynb @@ -11,7 +11,7 @@ "name": "stdout", "output_type": "stream", "text": [ - " [-----------------100%-----------------] 1000 of 1000 complete in 10.9 sec" + " [-----------------100%-----------------] 500 of 500 complete in 1.8 sec" ] }, { @@ -23,9 +23,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAI5CAYAAABTgvDdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWFwwpSVyDFUAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAALJCAYAAABGEOnEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -79,26 +79,90 @@ "\n", " # Data likelihood\n", " disasters = Poisson('disasters', rate, observed=disasters_data)\n", + " b = theano.tensor.set_subtensor(rate[5], 12) \n", + " a = Deterministic('a', disasters.sum())\n", "\n", + "n =500\n", + "with model:\n", "\n", - "def run(n=1000):\n", - " if n == \"short\":\n", - " n = 50\n", - " with model:\n", + " # Initial values for stochastic nodes\n", + " start = {'early_mean': 2., 'late_mean': 3.}\n", "\n", - " # Initial values for stochastic nodes\n", - " start = {'early_mean': 2., 'late_mean': 3.}\n", + " # Use slice sampler for means\n", + " step1 = Slice([early_mean, late_mean])\n", + " # Use Metropolis for switchpoint, since it accomodates discrete variables\n", + " \n", + " step2 = Metropolis([switchpoint] +model.missing_values)\n", "\n", - " # Use slice sampler for means\n", - " step1 = Slice([early_mean, late_mean])\n", - " # Use Metropolis for switchpoint, since it accomodates discrete variables\n", - " step2 = Metropolis([switchpoint] +model.missing_values)\n", - "\n", - " tr = sample(n, tune=500, start=start, step=[step1, step2])\n", - " traceplot(tr)\n", - "\n", - "if __name__ == '__main__':\n", - " run()\n" + " tr = sample(n, tune=500, start=start, step=[step1, step2])\n", + " traceplot(tr)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('int32')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.test_point['disasters_missing'].dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'int64'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('int32')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "disasters_data.dtype" ] }, { @@ -113,21 +177,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.3" + "pygments_lexer": "ipython3", + "version": "3.4.3" } }, "nbformat": 4, diff --git a/pymc3/model.py b/pymc3/model.py index b601812c99..1d6357ae90 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -380,7 +380,7 @@ class ObservedRV(Factor, TensorVariable): """Observed random variable that a model is specified in terms of. Potentially partially observed. """ - def __init__(self, name, data, distribution, model): + def __init__(self, type=None, owner=None, index=None, name=None, data=None, distribution=None, model=None): """ Parameters ---------- @@ -392,15 +392,23 @@ def __init__(self, name, data, distribution, model): distribution : Distribution model : Model """ - super(TensorVariable, self).__init__(distribution.type, None, None, name) + from .distributions import TensorType + if type is None: + data = pandas_to_array(data) + type = TensorType(data.dtype, data.shape) - data, self.missing_values = as_tensor(data) + super(TensorVariable, self).__init__(type, None, None, name) - self.logp_elemwiset = distribution.logp(data) - self.model = model - self.distribution = distribution + if distribution is not None: + data, self.missing_values = as_tensor(data, name) + + self.logp_elemwiset = distribution.logp(data) + self.model = model + self.distribution = distribution - theano.gof.Apply(identity, inputs=[data], outputs=[self]) + #make this RV a view on the combined missing/nonmissing array + theano.gof.Apply(theano.compile.view_op, inputs=[data], outputs=[self]) + self.tag.test_value = data.tag.test_value class MultiObservedRV(Factor): """Observed random variable that a model is specified in terms of. diff --git a/pymc3/theanof.py b/pymc3/theanof.py index 2bd89adb34..967debb74b 100644 --- a/pymc3/theanof.py +++ b/pymc3/theanof.py @@ -126,4 +126,4 @@ def __hash__(self): return hash(type(self)) scalar_identity = IdentityOp(scalar.upgrade_to_float, name='scalar_identity') -identity = tensor.Elemwise(scalar_identity, name='identity') +identity = t.Elemwise(scalar_identity, name='identity') From a04fec143041e5117724f26f3d3347602ff53320 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 02:16:39 -0700 Subject: [PATCH 14/24] fix non numpy data --- pymc3/model.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/pymc3/model.py b/pymc3/model.py index 1d6357ae90..ac63b364dd 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -151,13 +151,15 @@ def Var(self, name, dist, data=None): elif isinstance(data, dict): var = MultiObservedRV(name=name, data=data, distribution=dist, model=self) self.observed_RVs.append(var) - self.free_RVs += var.missing_values - self.missing_values += var.missing_values + if var.missing_values: + self.free_RVs += var.missing_values + self.missing_values += var.missing_values else: var = ObservedRV(name=name, data=data, distribution=dist, model=self) self.observed_RVs.append(var) - self.free_RVs.append(var.missing_values) - self.missing_values.append(var.missing_values) + if var.missing_values: + self.free_RVs.append(var.missing_values) + self.missing_values.append(var.missing_values) self.add_random_variable(var) return var @@ -357,8 +359,10 @@ def pandas_to_array(data): return np.ma.MaskedArray(data.values, data.isnull().values) else: return data.values - else: + elif hasattr(data, 'mask'): return data + else: + return np.asarray(data) def as_tensor(data, name): @@ -408,7 +412,8 @@ def __init__(self, type=None, owner=None, index=None, name=None, data=None, dist #make this RV a view on the combined missing/nonmissing array theano.gof.Apply(theano.compile.view_op, inputs=[data], outputs=[self]) - self.tag.test_value = data.tag.test_value + + self.tag.test_value = theano.compile.view_op(data).tag.test_value class MultiObservedRV(Factor): """Observed random variable that a model is specified in terms of. From 9e1cd02d85d9534a2aec674fdf3445f7b7197914 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 13:54:13 -0700 Subject: [PATCH 15/24] fix multiobservedrv --- pymc3/examples/arbitrary_stochastic.py | 2 +- pymc3/model.py | 23 ++++++++++------------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/pymc3/examples/arbitrary_stochastic.py b/pymc3/examples/arbitrary_stochastic.py index 0f9e1df105..0b96640645 100644 --- a/pymc3/examples/arbitrary_stochastic.py +++ b/pymc3/examples/arbitrary_stochastic.py @@ -9,7 +9,7 @@ def logp(failure, value): return sum(failure * log(lam) - lam * value) - x = DensityDist('x', logp, observed=(failure, value)) + x = DensityDist('x', logp, observed={'failure':failure, 'value':value}) def run (n=3000): diff --git a/pymc3/model.py b/pymc3/model.py index ac63b364dd..5747657da6 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -376,9 +376,12 @@ def as_tensor(data, name): constant = t.as_tensor_variable(data.filled()) dataTensor = theano.tensor.set_subtensor(constant[data.mask.nonzero()], missing_values) - return dataTensor, missing_values + dataTensor.missing_values = missing_values + return dataTensor else: - return t.as_tensor_variable(data, name=name), None + data = t.as_tensor_variable(data, name=name) + data.missing_values = None + return data class ObservedRV(Factor, TensorVariable): """Observed random variable that a model is specified in terms of. @@ -404,7 +407,8 @@ def __init__(self, type=None, owner=None, index=None, name=None, data=None, dist super(TensorVariable, self).__init__(type, None, None, name) if distribution is not None: - data, self.missing_values = as_tensor(data, name) + data = as_tensor(data, name) + self.missing_values = data.missing_values self.logp_elemwiset = distribution.logp(data) self.model = model @@ -432,18 +436,11 @@ def __init__(self, name, data, distribution, model): model : Model """ self.name = name - data_arrays = as_iterargs(data) - - if len(data_arrays) > 1: - names = [name + "_" + param for param in getargspec(distribution.logp).args] - else: - names = [name] - data_arrays = [as_tensor(data, name) for data, name in zip(data_arrays,names)] - self.data = [d for d, missing in data_arrays] - self.missing_values = [missing for d, missing in data_arrays if missing is not None] + self.data = { name : as_tensor(data, name) for name, data in data.items()} - self.logp_elemwiset = distribution.logp(*data_arrays) + self.missing_values = [ data.missing_values for data in self.data.values() if data.missing_values is not None] + self.logp_elemwiset = distribution.logp(**self.data) self.model = model self.distribution = distribution From d5916b6cae69785440f42ad1d08324d93dd7d13b Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 13:57:24 -0700 Subject: [PATCH 16/24] fix disasters missing --- pymc3/examples/disaster_model_missing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymc3/examples/disaster_model_missing.py b/pymc3/examples/disaster_model_missing.py index 359dc9dd6d..ad8b043584 100644 --- a/pymc3/examples/disaster_model_missing.py +++ b/pymc3/examples/disaster_model_missing.py @@ -58,7 +58,7 @@ def run(n=1000): # Use slice sampler for means step1 = Slice([early_mean, late_mean]) # Use Metropolis for switchpoint, since it accomodates discrete variables - step2 = Metropolis([switchpoint]) + step2 = Metropolis([switchpoint, disasters.missing_values ]) tr = sample(n, tune=500, start=start, step=[step1, step2]) From af4cb94a5393f88fba3dd849dbbf11b7b9383999 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 16:45:19 -0700 Subject: [PATCH 17/24] handle gradient when no vars are passed --- pymc3/theanof.py | 16 +++++++++++++--- pymc3/vartypes.py | 2 +- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/pymc3/theanof.py b/pymc3/theanof.py index 967debb74b..489e47b7a4 100644 --- a/pymc3/theanof.py +++ b/pymc3/theanof.py @@ -43,12 +43,16 @@ def gradient1(f, v): return t.flatten(t.grad(f, v, disconnected_inputs='warn')) +empty_gradient = t.zeros(0, dtype='float32') @memoize def gradient(f, vars=None): if vars is None: vars = cont_inputs(f) - return t.concatenate([gradient1(f, v) for v in vars], axis=0) + if vars: + return t.concatenate([gradient1(f, v) for v in vars], axis=0) + else: + return empty_gradient def jacobian1(f, v): @@ -67,7 +71,10 @@ def jacobian(f, vars=None): if vars is None: vars = cont_inputs(f) - return t.concatenate([jacobian1(f, v) for v in vars], axis=1) + if vars: + return t.concatenate([jacobian1(f, v) for v in vars], axis=1) + else: + return empty_gradient @memoize @@ -91,7 +98,10 @@ def hessian_diag(f, vars=None): if vars is None: vars = cont_inputs(f) - return -t.concatenate([hessian_diag1(f, v) for v in vars], axis=0) + if vars: + return -t.concatenate([hessian_diag1(f, v) for v in vars], axis=0) + else: + return empty_gradient def makeiter(a): diff --git a/pymc3/vartypes.py b/pymc3/vartypes.py index cfe046828a..24a7225a59 100644 --- a/pymc3/vartypes.py +++ b/pymc3/vartypes.py @@ -22,4 +22,4 @@ def typefilter(vars, types): # Returns variables of type `types` from `vars` - return filter(lambda v: v.dtype in types, vars) + return [v for v in vars if v.dtype in types] From e3319d85fd81905271f8376cc65d6101b8f8331f Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 16:46:33 -0700 Subject: [PATCH 18/24] give missing variables the .model parameter --- pymc3/model.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pymc3/model.py b/pymc3/model.py index 5747657da6..e6536aa539 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -365,13 +365,13 @@ def pandas_to_array(data): return np.asarray(data) -def as_tensor(data, name): +def as_tensor(data, name,model): data = pandas_to_array(data) if hasattr(data, 'mask'): from .distributions import NoDistribution fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=data.dtype, testval=data.mask.mean().astype(data.dtype)) - missing_values = FreeRV(name=name + '_missing', distribution=fakedist) + missing_values = FreeRV(name=name + '_missing', distribution=fakedist, model=model) constant = t.as_tensor_variable(data.filled()) @@ -407,7 +407,7 @@ def __init__(self, type=None, owner=None, index=None, name=None, data=None, dist super(TensorVariable, self).__init__(type, None, None, name) if distribution is not None: - data = as_tensor(data, name) + data = as_tensor(data, name,model) self.missing_values = data.missing_values self.logp_elemwiset = distribution.logp(data) @@ -437,7 +437,7 @@ def __init__(self, name, data, distribution, model): """ self.name = name - self.data = { name : as_tensor(data, name) for name, data in data.items()} + self.data = { name : as_tensor(data, name,model) for name, data in data.items()} self.missing_values = [ data.missing_values for data in self.data.values() if data.missing_values is not None] self.logp_elemwiset = distribution.logp(**self.data) From 90b4d2ca8df1da2014336ac0c3c4b7ec5079ac52 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 16:53:57 -0700 Subject: [PATCH 19/24] use the right datatype for the missing values --- pymc3/model.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pymc3/model.py b/pymc3/model.py index e6536aa539..ec44d81fbf 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -365,12 +365,12 @@ def pandas_to_array(data): return np.asarray(data) -def as_tensor(data, name,model): - data = pandas_to_array(data) +def as_tensor(data, name,model, dtype): + data = pandas_to_array(data).astype(dtype) if hasattr(data, 'mask'): from .distributions import NoDistribution - fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=data.dtype, testval=data.mask.mean().astype(data.dtype)) + fakedist = NoDistribution.dist(shape=data.mask.sum(), dtype=dtype, testval=data.mean().astype(dtype)) missing_values = FreeRV(name=name + '_missing', distribution=fakedist, model=model) constant = t.as_tensor_variable(data.filled()) @@ -402,12 +402,12 @@ def __init__(self, type=None, owner=None, index=None, name=None, data=None, dist from .distributions import TensorType if type is None: data = pandas_to_array(data) - type = TensorType(data.dtype, data.shape) + type = TensorType(distribution.dtype, data.shape) super(TensorVariable, self).__init__(type, None, None, name) if distribution is not None: - data = as_tensor(data, name,model) + data = as_tensor(data, name,model,distribution.dtype) self.missing_values = data.missing_values self.logp_elemwiset = distribution.logp(data) @@ -437,7 +437,7 @@ def __init__(self, name, data, distribution, model): """ self.name = name - self.data = { name : as_tensor(data, name,model) for name, data in data.items()} + self.data = { name : as_tensor(data, name, model, distribution.dtype) for name, data in data.items()} self.missing_values = [ data.missing_values for data in self.data.values() if data.missing_values is not None] self.logp_elemwiset = distribution.logp(**self.data) From 0af9cffe86e553b43ee45c3c2c593616d11b3913 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 17:03:56 -0700 Subject: [PATCH 20/24] make lasso missing work --- pymc3/examples/lasso_missing.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/pymc3/examples/lasso_missing.py b/pymc3/examples/lasso_missing.py index 1aba42e54b..6d6464aaf8 100644 --- a/pymc3/examples/lasso_missing.py +++ b/pymc3/examples/lasso_missing.py @@ -25,26 +25,25 @@ p_mother = Beta('p_mother', 1, 1) mother_imp = Bernoulli('mother_imp', p_mother, observed=masked_values(mother_hs, value=-999)) - s = HalfCauchy('s', 5) - beta = Laplace('beta', 0, 100, shape=7) + s = HalfCauchy('s', 5, testval=5) + beta = Laplace('beta', 0, 100, shape=7, testval=.1) - p = (beta[0] + beta[1]*male + beta[2]*siblings_imp + beta[3]*disability_imp + + expected_score = (beta[0] + beta[1]*male + beta[2]*siblings_imp + beta[3]*disability_imp + beta[4]*age + beta[5]*mother_imp + beta[6]*early_ident) observed_score = Normal('observed_score', expected_score, s ** -2, observed=score) with model: - step1 = NUTS([beta, s, p_disab, p_mother, sib_mean]) + start = find_MAP() + step1 = NUTS([beta, s, p_disab, p_mother, sib_mean], scaling=start) step2 = Metropolis([mother_imp.missing_values, disability_imp.missing_values, siblings_imp.missing_values]) def run(n=5000): - with model: - start = find_MAP() trace = sample(n, [step1, step2], start) From 0b336cf58077551752d1f6d35575e88f13478186 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 18:14:53 -0700 Subject: [PATCH 21/24] add fake data for missing lasso example --- pymc3/examples/data/test_scores.csv | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 pymc3/examples/data/test_scores.csv diff --git a/pymc3/examples/data/test_scores.csv b/pymc3/examples/data/test_scores.csv new file mode 100644 index 0000000000..c3f1da1856 --- /dev/null +++ b/pymc3/examples/data/test_scores.csv @@ -0,0 +1,17 @@ +score,male,sib,synd_or_disab,age_test,mother_hs,ident_by_3 +100,0,1,0,5,1,0 +35,0,2,0,9,0,1 +24,1,NaN,1,7,1,0 +75,1,0,0,2,1,1 +24,1,NaN,1,7,1,0 +81,1,0,0,2,1,1 +24,1,3,1,7,1,0 +64,1,0,NaN,11,1,0 +18,1,1,1,9,1,0 +24,1,1,0,8,0,0 +24,1,1,1,7,1,0 +76,0,2,0,2,NaN,0 +36,0,1,0,2,1,1 +16,1,1,0,2,0,0 +95,0,0,0,2,NaN,1 +65,1,2,0,2,0,1 From d57fc132ec4916f269db4af78d689bedc7d35093 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 18:59:34 -0700 Subject: [PATCH 22/24] need n='short' for auto running --- pymc3/examples/lasso_missing.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pymc3/examples/lasso_missing.py b/pymc3/examples/lasso_missing.py index 6d6464aaf8..b707bff214 100644 --- a/pymc3/examples/lasso_missing.py +++ b/pymc3/examples/lasso_missing.py @@ -43,6 +43,8 @@ siblings_imp.missing_values]) def run(n=5000): + if n == 'short': + n = 100 with model: trace = sample(n, [step1, step2], start) From 608c01104de94e2fa60aedebb81aef6cc881e632 Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Thu, 4 Jun 2015 19:03:48 -0700 Subject: [PATCH 23/24] increase samples to get summary to work --- pymc3/examples/disaster_model_missing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymc3/examples/disaster_model_missing.py b/pymc3/examples/disaster_model_missing.py index ad8b043584..fc4fde52f3 100644 --- a/pymc3/examples/disaster_model_missing.py +++ b/pymc3/examples/disaster_model_missing.py @@ -49,7 +49,7 @@ def run(n=1000): if n == "short": - n = 50 + n = 500 with model: # Initial values for stochastic nodes From 469ec7bc083f7dea03c3c12b22e002e368aeb2fe Mon Sep 17 00:00:00 2001 From: John Salvatier Date: Sun, 7 Jun 2015 14:37:48 -0700 Subject: [PATCH 24/24] support shared variables --- pymc3/model.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pymc3/model.py b/pymc3/model.py index ec44d81fbf..8e89b3d831 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -361,6 +361,8 @@ def pandas_to_array(data): return data.values elif hasattr(data, 'mask'): return data + elif isinstance(data, theano.gof.graph.Variable): + return data else: return np.asarray(data)