import pymc as mc -> pm in chapter 3 + typos

Author: cebe

Chapter3_MCMC/IntroMCMC.ipynb

@@ -213,7 +213,7 @@
       "plt.title(\"Landscape formed by Uniform priors on $p_1, p_2$.\")\n",
       "\n",
       "subplot(223)\n",
-      "plt.contour(X, Y, M * L)\n",
+      "plt.contour(x, y, M * L)\n",
       "im = plt.imshow(M * L, interpolation='none', origin='lower',\n",
       "                cmap=cm.jet, extent=(0, 5, 0, 5))\n",
       "plt.title(\"Landscape warped by %d data observation;\\n Uniform priors on $p_1, p_2$.\" % N)\n",
@@ -226,7 +226,7 @@
       "exp_y = stats.expon.pdf(x, loc=0, scale=10)\n",
       "M = np.dot(exp_x[:, None], exp_y[None, :])\n",
       "\n",
-      "plt.contour(X, Y, M)\n",
+      "plt.contour(x, y, M)\n",
       "im = plt.imshow(M, interpolation='none', origin='lower',\n",
       "                cmap=cm.jet, extent=(0, 5, 0, 5))\n",
       "plt.scatter(lambda_2_true, lambda_1_true, c=\"k\", s=50, edgecolor=\"none\")\n",
@@ -236,7 +236,7 @@
       "\n",
       "subplot(224)\n",
       "# This is the likelihood times prior, that results in the posterior.\n",
-      "plt.contour(X, Y, M * L)\n",
+      "plt.contour(x, y, M * L)\n",
       "im = plt.imshow(M * L, interpolation='none', origin='lower',\n",
       "                cmap=cm.jet, extent=(0, 5, 0, 5))\n",
       "\n",
@@ -383,11 +383,11 @@
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "import pymc as mc\n",
+      "import pymc as pm\n",
       "\n",
-      "p = mc.Uniform(\"p\", 0, 1)\n",
+      "p = pm.Uniform(\"p\", 0, 1)\n",
       "\n",
-      "assignment = mc.Categorical(\"assignment\", [p, 1-p], size=data.shape[0])\n",
+      "assignment = pm.Categorical(\"assignment\", [p, 1-p], size=data.shape[0])\n",
       "print \"prior assignment, with p = %.2f:\" % p.value\n",
       "print assignment.value[:10], \"...\""
      ],
@@ -415,7 +415,7 @@
       "\n",
       "In PyMC, we can do this in one step by writing:\n",
       "\n",
-      "    taus = 1.0/mc.Uniform( \"stds\", 0, 100, size= 2)**2 \n",
+      "    taus = 1.0/pm.Uniform( \"stds\", 0, 100, size= 2)**2 \n",
       "\n",
       "Notice that we specified `size=2`: we are modeling both $\\tau$s as a single PyMC variable. Note that is does not induce a necessary relationship between the two $\\tau$s, it is simply for succinctness.\n",
       "\n",
@@ -426,21 +426,21 @@
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "taus = 1.0/mc.Uniform(\"stds\", 0, 100, size=2) ** 2\n",
-      "centers = mc.Normal(\"centers\", [120, 190], [0.01, 0.01], size=2)\n",
+      "taus = 1.0/pm.Uniform(\"stds\", 0, 100, size=2) ** 2\n",
+      "centers = pm.Normal(\"centers\", [120, 190], [0.01, 0.01], size=2)\n",
       "\n",
       "\"\"\"\n",
-      "The below deterministic functions map a assignment, in this case 0 or 1,\n",
-      "to a set of parameters, located in the (1,2) arrays `taus` and `centers.`\n",
+      "The below deterministic functions map an assignment, in this case 0 or 1,\n",
+      "to a set of parameters, located in the (1,2) arrays `taus` and `centers`.\n",
       "\"\"\"\n",
       "\n",
       "\n",
-      "@mc.deterministic\n",
+      "@pm.deterministic\n",
       "def center_i(assignment=assignment, centers=centers):\n",
       "    return centers[assignment]\n",
       "\n",
       "\n",
-      "@mc.deterministic\n",
+      "@pm.deterministic\n",
       "def tau_i(assignment=assignment, taus=taus):\n",
       "    return taus[assignment]\n",
       "\n",
@@ -469,10 +469,10 @@
      "collapsed": false,
      "input": [
       "#and to combine it with the observations:\n",
-      "observations = mc.Normal(\"obs\", center_i, tau_i, value=data, observed=True)\n",
+      "observations = pm.Normal(\"obs\", center_i, tau_i, value=data, observed=True)\n",
       "\n",
       "#below we create a model class\n",
-      "model = mc.Model([p, assignment, taus, centers])"
+      "model = pm.Model([p, assignment, taus, centers])"
      ],
      "language": "python",
      "metadata": {},
@@ -485,7 +485,7 @@
      "source": [
       "PyMC has an MCMC class, `MCMC` in the main namespace of PyMC, that implements the MCMC exploring algorithm. We initialize it by passing in a `Model` instance:\n",
       "\n",
-      "    mcmc = mc.MCMC( model )\n",
+      "    mcmc = pm.MCMC( model )\n",
       "\n",
       "The method for asking the `MCMC` to explore the space is `sample( iterations )`, where `iterations` is the number of steps you wish the algorithm to perform. We try 50000 steps below:"
      ]
@@ -494,7 +494,7 @@
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "mcmc = mc.MCMC(model)\n",
+      "mcmc = pm.MCMC(model)\n",
       "mcmc.sample(50000)"
      ],
      "language": "python",
@@ -574,7 +574,7 @@
       "3. The traces appear as a random \"walk\" around the space, that is, the paths exhibit correlation with previous positions. This is both good and bad. We will always have correlation between current positions and the previous positions, but too much of it means we are not exploring the space well. This will be detailed in the Diagnostics section  later in this chapter.\n",
       "\n",
       "\n",
-      "To achieve further convergence, we will perform more MCMC steps. Starting the MCMC again after it has already been called does not mean starting the entire algorithm over. In the pseudo-code algorithm of MCMC above, the only position that matters is the current position (new positions are investigated near the current position), implicitly stored in PyMC variables' `value` attribute. Thus it is fine to halt an MCMC algorithm and inspect its progress, with the intention of starting it up again later. The `value' attributes are not overwritten. \n",
+      "To achieve further convergence, we will perform more MCMC steps. Starting the MCMC again after it has already been called does not mean starting the entire algorithm over. In the pseudo-code algorithm of MCMC above, the only position that matters is the current position (new positions are investigated near the current position), implicitly stored in PyMC variables' `value` attribute. Thus it is fine to halt an MCMC algorithm and inspect its progress, with the intention of starting it up again later. The `value` attributes are not overwritten. \n",
       "\n",
       "We will sample the MCMC one hundred thousand more times and visualize the progress below:"
      ]
@@ -807,12 +807,12 @@
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "import pymc as mc\n",
+      "import pymc as pm\n",
       "\n",
-      "x = mc.Normal(\"x\", 4, 10)\n",
-      "y = mc.Lambda(\"y\", lambda x=x: 10 - x, trace=True)\n",
+      "x = pm.Normal(\"x\", 4, 10)\n",
+      "y = pm.Lambda(\"y\", lambda x=x: 10 - x, trace=True)\n",
       "\n",
-      "ex_mcmc = mc.MCMC(mc.Model([x, y]))\n",
+      "ex_mcmc = pm.MCMC(pm.Model([x, y]))\n",
       "ex_mcmc.sample(500)\n",
       "\n",
       "plt.plot(ex_mcmc.trace(\"x\")[:])\n",
@@ -930,7 +930,7 @@
       "\n",
       "Of course, we do not know where the MAP is. PyMC provides an object that will approximate, if not find, the MAP location. In the PyMC main namespace is the `MAP` object that accepts a PyMC `Model` instance. Calling `.fit()` from the `MAP` instance sets the variables in the model to their MAP values.\n",
       "\n",
-      "    map_ = mc.MAP( model )\n",
+      "    map_ = pm.MAP( model )\n",
       "    map_.fit()\n",
       "\n",
       "The `MAP.fit()` methods has the flexibility of allowing the user to choose which optimization algorithm to use (after all, this is a optimization problem: we are looking for the values that maximize our landscape), as not all optimization algorithms are created equal. The default optimization algorithm in the call to `fit` is scipy's `fmin` algorithm (which attempts to minimize the *negative of the landscape*). An alternative algorithm that is available is Powell's Method, a favourite of PyMC blogger [Abraham Flaxman](http://healthyalgorithms.com/) [1], by calling `fit(method='fmin_powell')`. From my experience, I use the default, but if my convergence is slow or not guaranteed, I experiment with Powell's method. \n",
@@ -943,12 +943,12 @@
       "\n",
       "It is still a good idea to provide a burn-in period, even if we are using `MAP` prior to calling `MCMC.sample`, just to be safe. We can have PyMC automatically discard the first $n$ samples by specifying the `burn` parameter in the call to `sample`. As one does not know when the chain has fully converged, I like to assign the first *half* of my samples to be discarded, sometimes up to 90% of my samples for longer runs. To continue the clustering example from above, my new code would look something like:\n",
       "\n",
-      "    model = mc.Model( [p, assignment, taus, centers ] )\n",
+      "    model = pm.Model( [p, assignment, taus, centers ] )\n",
       "\n",
-      "    map_ = mc.MAP( model )\n",
+      "    map_ = pm.MAP( model )\n",
       "    map_.fit() #stores the fitted variables' values in foo.value\n",
       "\n",
-      "    mcmc = mc.MCMC( model )\n",
+      "    mcmc = pm.MCMC( model )\n",
       "    mcmc.sample( 100000, 50000 )\n"
      ]
     },
@@ -978,12 +978,12 @@
      "input": [
       "figsize(12.5, 4)\n",
       "\n",
-      "import pymc as mc\n",
-      "x_t = mc.rnormal(0, 1, 200)\n",
+      "import pymc as pm\n",
+      "x_t = pm.rnormal(0, 1, 200)\n",
       "x_t[0] = 0\n",
       "y_t = np.zeros(200)\n",
       "for i in range(1, 200):\n",
-      "    y_t[i] = mc.rnormal(y_t[i - 1], 1)\n",
+      "    y_t[i] = pm.rnormal(y_t[i - 1], 1)\n",
       "\n",
       "plt.plot(y_t, label=\"$y_t$\", lw=3)\n",
       "plt.plot(x_t, label=\"$x_t$\", lw=3)\n",
@@ -1055,7 +1055,7 @@
       "\n",
       "A chain that is [Isn't meandering exploring?] exploring the space well will exhibit very high autocorrelation. Visually, if the trace seems to meander like a river, and not settle down, the chain will have high autocorrelation.\n",
       "\n",
-      "This does not imply that a converged MCMC has low autocorrelation. Hence low autocorrelation is not necessary for convergence, but it is sufficient. PyMC has an built-in autocorrelation plotting function in the `Matplot` module. "
+      "This does not imply that a converged MCMC has low autocorrelation. Hence low autocorrelation is not necessary for convergence, but it is sufficient. PyMC has a built-in autocorrelation plotting function in the `Matplot` module. "
      ]
     },
     {
@@ -1107,7 +1107,7 @@
       "\n",
       "What is a good amount of thinning? The returned samples will always exhibit some autocorrelation, regardless of how much thinning is done. So long as the autocorrelation tends to zero, you are probably ok. Typically thinning of more than 10 is not necessary.\n",
       "\n",
-      "PyMC exposes a `thinning` parameter in the call the `sample`, for example: `sample( 10000, burn = 5000, thinning = 5)`. "
+      "PyMC exposes a `thinning` parameter in the call to `sample`, for example: `sample( 10000, burn = 5000, thinning = 5)`. "
      ]
     },
     {
@@ -1198,9 +1198,9 @@
       "\n",
       "### Intelligent starting values\n",
       "\n",
-      "It would be great to start the MCMC algorithm off near the posterior distribution, so that it will take little time to start sampling correctly. We can aid the algorithm by telling where we *think* the posterior distribution will be by specifying the `value` parameter in the `Stochastic` variable creation. In many cases we can produce a reasonable guess for the parameter. For example, if we have data from a Normal distribution, and we wish to estimate the $\\mu$ parameter, then a good starting value would the *mean* of the data. \n",
+      "It would be great to start the MCMC algorithm off near the posterior distribution, so that it will take little time to start sampling correctly. We can aid the algorithm by telling where we *think* the posterior distribution will be by specifying the `value` parameter in the `Stochastic` variable creation. In many cases we can produce a reasonable guess for the parameter. For example, if we have data from a Normal distribution, and we wish to estimate the $\\mu$ parameter, then a good starting value would be the *mean* of the data. \n",
       "\n",
-      "     mu = mc.Uniform( \"mu\", 0, 100, value = data.mean() )\n",
+      "     mu = pm.Uniform( \"mu\", 0, 100, value = data.mean() )\n",
       "\n",
       "For most parameters in models, there is a frequentist estimate of it. These estimates are a good starting value for our MCMC algorithms. Of course, this is not always possible for some variables, but including as many appropriate initial values is always a good idea. Even if your guesses are wrong, the MCMC will still converge to the proper distribution, so there is little to lose.\n",
       "\n",
@@ -1338,4 +1338,4 @@
    "metadata": {}
   }
  ]
-}
+}