PyMC rename, API and typo fixes

Author: michaelosthege

README.md

@@ -13,8 +13,8 @@ functions using symbolic differentiation and common subexpression elimination.
 In either case the functions are compiled using numba and the resulting
 C-function is passed to sunode, so that there is no python overhead.
 
-sunode comes with a theano wrapper so that parameters of an ode can be estimated
-using pymc3.
+`sunode` comes with an Aesara wrapper so that parameters of an ODE can be estimated
+using PyMC.
 
 ### Installation
 sunode is available on conda-forge. Set up a conda environment to use conda-forge
@@ -28,8 +28,8 @@ conda config --set channel_priority strict
 conda install sunode
 ```
 
-You can also install the development version. One windows you have to make
-sure the correct visual studio version is install and in the PATH.
+You can also install the development version. On Windows you have to make
+sure the correct Visual Studio version is installed and in the PATH.
 ```
 git clone [email protected]:aseyboldt/sunode
 # Or if no ssh key is configured:
@@ -40,7 +40,7 @@ conda install --only-deps sunode
 pip install -e .
 ```
 
-### Solve an ode outside of a pymc3 model
+### Solve an ODE outside a PyMC model
 
 We will use the Lotka-Volterra equations as an example ODE:
 
@@ -118,22 +118,22 @@ plt.plot(output.view(problem.state_dtype)['hares']
 ```
 
 For this example the BDF solver (which isn't the best solver for a small non-stiff
-example problem like this) takes ~200μs, while the scipy.integrate.solve_ivp solver
-take about 40ms at a tolerance of 1e-10, 1e-10. So we are faster by a factor of 200.
+example problem like this) takes ~200μs, while the `scipy.integrate.solve_ivp` solver
+takes about 40ms at a tolerance of 1e-10, 1e-10. So we are faster by a factor of 200.
 This advantage will get somewhat smaller for large problems however, when the
-python overhead of the ODE solver has a smaller impact.
+Python overhead of the ODE solver has a smaller impact.
 
-### Usage in pymc3
+### Usage in PyMC
 
-Let's use the same ODE, but fit the parameters using pymc3, and gradients
-computed using sunode.
+Let's use the same ODE, but fit the parameters using PyMC, and gradients
+computed using `sunode`.
 
 We'll use some time artificial data:
 ```python
 import numpy as np
 import sunode
 import sunode.wrappers.as_aesara
-import pymc3 as pm
+import pymc as pm
 
 times = np.arange(1900,1921,1)
 lynx_data = np.array([
@@ -164,18 +164,18 @@ def lotka_volterra(t, y, p):
 
 
 with pm.Model() as model:
-    hares_start = pm.HalfNormal('hares_start', sd=50)
-    lynx_start = pm.HalfNormal('lynx_start', sd=50)
+    hares_start = pm.HalfNormal('hares_start', sigma=50)
+    lynx_start = pm.HalfNormal('lynx_start', sigma=50)
 
     ratio = pm.Beta('ratio', alpha=0.5, beta=0.5)
 
-    fixed_hares = pm.HalfNormal('fixed_hares', sd=50)
+    fixed_hares = pm.HalfNormal('fixed_hares', sigma=50)
     fixed_lynx = pm.Deterministic('fixed_lynx', ratio * fixed_hares)
 
-    period = pm.Gamma('period', mu=10, sd=1)
+    period = pm.Gamma('period', mu=10, sigma=1)
     freq = pm.Deterministic('freq', 2 * np.pi / period)
 
-    log_speed_ratio = pm.Normal('log_speed_ratio', mu=0, sd=0.1)
+    log_speed_ratio = pm.Normal('log_speed_ratio', mu=0, sigma=0.1)
     speed_ratio = np.exp(log_speed_ratio)
 
     # Compute the parameters of the ode based on our prior parameters
@@ -217,18 +217,18 @@ with pm.Model() as model:
     pm.Deterministic('lynx_mu', y_hat['lynx'])
 
     sd = pm.HalfNormal('sd')
-    pm.Lognormal('hares', mu=y_hat['hares'], sd=sd, observed=hare_data)
-    pm.Lognormal('lynx', mu=y_hat['lynx'], sd=sd, observed=lynx_data)
+    pm.LogNormal('hares', mu=y_hat['hares'], sigma=sd, observed=hare_data)
+    pm.LogNormal('lynx', mu=y_hat['lynx'], sigma=sd, observed=lynx_data)
 ```
 
-We can sample using pymc3 (You need `cores=1` on windows for the moment):
+We can sample using PyMC (You need `cores=1` on Windows for the moment):
 ```
 with model:
-    trace = pm.sample(tune=1000, draws=1000, chains=6, cores=6)
+    idata = pm.sample(tune=1000, draws=1000, chains=6, cores=6)
 ```
 
 Many solver options can not be specified with a nice interface for now,
-we can call the raw sundials functions howeve:
+we can call the raw sundials functions however:
 
 ```
 lib = sunode._cvodes.lib

doc/source/index.rst

@@ -27,7 +27,7 @@ through AST manipulation for necessary functions and compile them using numba.
 This allows us to solve an ode repeatetly with almost no python overhead.
 
 The original use-case for this library was better support for solving ODEs
-within bayesian models in PyMC3, but is useable in different contexts as well.
+within bayesian models in PyMC, but is useable in different contexts as well.
 
 Contents
 --------

doc/source/quickstart_pymc.rst

@@ -1,7 +1,7 @@
-.. _quickstart_pymc3:
+.. _quickstart_pymc:
 
-Quickstart with PyMC3
-=====================
+Quickstart with PyMC
+====================
 
 sunode is available on conda-forge. You can setup an environmet to use conda-forge
 package if you don't have that already, and install sunode:::
@@ -30,7 +30,7 @@ Sampling Bayesian models with Hamiltonian MCMC involving an ODE is where the
 features of sunode shine.  We need to solve the ODE (ofter rather small ODEs) a
 large number of times, so Python overhead will hurt us a lot, and we need to
 compute gradients as well. Sunode provides some utility functions that make it
-easy to include an ODE into a PyMC3 model.  If you want to use it in a
+easy to include an ODE into a PyMC model.  If you want to use it in a
 different context, see :ref:`usage-basic`.
 We will use the Lotka-Volterra equations as example:
 
@@ -43,7 +43,7 @@ We'll use some time artificial data:::
     import numpy as np
     import sunode
     import sunode.wrappers.as_aesara
-    import pymc3 as pm
+    import pymc as pm
 
     times = np.arange(1900,1921,1)
     lynx_data = np.array([
@@ -72,25 +72,25 @@ We also define a function for the right-hand-side of the ODE:::
 
    For more details about how this function behaves, see :ref:`rhs-function`.
 
-In the next step we define priors for our parameters in PyMC3. To illustrate
-that the parameters do not have to be PyMC3 variables themselves, but can also
+In the next step we define priors for our parameters in PyMC. To illustrate
+that the parameters do not have to be PyMC variables themselves, but can also
 be derived though some computations, we put priors not on :math:`\alpha, \beta,
 \gamma` and :math:`\delta`, but on parameters like the frequency of the
 hare-lynx cycle and the steady-state ratio of hares to lynxes.::
 
     with pm.Model() as model:
-        hares_start = pm.HalfNormal('hares_start', sd=50)
-        lynx_start = pm.HalfNormal('lynx_start', sd=50)
+        hares_start = pm.HalfNormal('hares_start', sigma=50)
+        lynx_start = pm.HalfNormal('lynx_start', sigma=50)
 
         ratio = pm.Beta('ratio', alpha=0.5, beta=0.5)
 
-        fixed_hares = pm.HalfNormal('fixed_hares', sd=50)
+        fixed_hares = pm.HalfNormal('fixed_hares', sigma=50)
         fixed_lynx = pm.Deterministic('fixed_lynx', ratio * fixed_hares)
 
-        period = pm.Gamma('period', mu=10, sd=1)
+        period = pm.Gamma('period', mu=10, sigma=1)
         freq = pm.Deterministic('freq', 2 * np.pi / period)
 
-        log_speed_ratio = pm.Normal('log_speed_ratio', mu=0, sd=0.1)
+        log_speed_ratio = pm.Normal('log_speed_ratio', mu=0, sigma=0.1)
         speed_ratio = np.exp(log_speed_ratio)
 
         # Compute the parameters of the ode based on our prior parameters
@@ -143,10 +143,10 @@ We are only missing the likelihood now::
         pm.Deterministic('lynxes_mu', solution['lynxes'])
 
         sd = pm.HalfNormal('sd')
-        pm.Lognormal('hares', mu=solution['hares'], sd=sd, observed=hare_data)
-        pm.Lognormal('lynxes', mu=solution['lynxes'], sd=sd, observed=lynx_data)
+        pm.LogNormal('hares', mu=solution['hares'], sigma=sd, observed=hare_data)
+        pm.LogNormal('lynxes', mu=solution['lynxes'], sigma=sd, observed=lynx_data)
 
-We can sample from the posterior with the gradient-based PyMC3 samplers:::
+We can sample from the posterior with the gradient-based PyMC samplers:::
 
     with model:
         trace = pm.sample()
@@ -161,3 +161,4 @@ This is the default on Linux, but on Mac it has to be specified manually::
 
 Windows does not support this at all. You can however disable parallel sampling
 by setting ``cores=1`` in ``pm.sample()``.
+diff --git a/doc/source/quickstart_pymc3.rst b/doc/source/quickstart_pymc3.rst

doc/source/without_pymc.rst

@@ -12,7 +12,7 @@ current number, and die when eaten by a lynx. We get:
 .. math::
    \frac{dH}{dt} = \alpha H - \beta LH \\ \frac{dL}{dt} = \delta LH - \gamma L
 
-If we want to solve this ODE without the support of theano or PyMC3, we need to
+If we want to solve this ODE without the support of Aesara or PyMC, we need to
 first declare the parameters and states we are using. We have four parameters
 and two states, and each one is a scalar values, so it has shape ()::