From b5b63f5d6c8d5891382cce1af9bd5ea22de795cf Mon Sep 17 00:00:00 2001
From: Ricardo Vieira <ricardo.vieira1994@gmail.com>
Date: Tue, 18 Oct 2022 10:09:38 +0200
Subject: [PATCH] Fix debug_print of wrong variable in notebook

---
 .../learn/core_notebooks/pymc_aesara.ipynb    | 1167 +++++------------
 1 file changed, 300 insertions(+), 867 deletions(-)

diff --git a/docs/source/learn/core_notebooks/pymc_aesara.ipynb b/docs/source/learn/core_notebooks/pymc_aesara.ipynb
index 5cd1264883b..18e17329ae4 100644
--- a/docs/source/learn/core_notebooks/pymc_aesara.ipynb
+++ b/docs/source/learn/core_notebooks/pymc_aesara.ipynb
@@ -2,11 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "(pymc_aesara)=\n",
     "\n",
@@ -20,10 +16,7 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "heading_collapsed": true,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
+    "heading_collapsed": true
    },
    "source": [
     "## Prepare Notebook\n",
@@ -33,49 +26,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 1,
    "metadata": {
-    "hidden": true,
-    "pycharm": {
-     "name": "#%%\n"
-    }
+    "hidden": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "# Aesara version: 2.7.9\n",
-      "# PyMC version: 4.1.4\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import aesara\n",
     "import aesara.tensor as at\n",
     "import pymc as pm\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
-    "import scipy.stats\n",
-    "\n",
-    "\n",
-    "print(\n",
-    "    f\"\"\"\n",
-    "# Aesara version: {aesara.__version__}\n",
-    "# PyMC version: {pm.__version__}\n",
-    "\"\"\"\n",
-    ")"
+    "import scipy.stats"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "## Introduction to Aesara\n",
     "\n",
@@ -86,22 +53,14 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "![aesara logo](https://raw.githubusercontent.com/aesara-devs/aesara/main/doc/images/aesara_logo_2400.png)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### A simple example\n",
     "\n",
@@ -110,12 +69,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 2,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -148,23 +103,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Now that we have defined the `x` and `y` tensors, we can create a new one by adding them together."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [],
    "source": [
     "z = x + y\n",
@@ -173,23 +120,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "To make the computation a bit more complex let us take the logarithm of the resulting tensor."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 4,
+   "metadata": {},
    "outputs": [],
    "source": [
     "w = at.log(z)\n",
@@ -198,23 +137,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We can use the {func}`~aesara.dprint` function to print the computational graph of any given tensor."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 5,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -229,11 +160,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 11,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -244,23 +173,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Note that this graph does not do any computation (yet!). It is simply defining the sequence of steps to be done. We can use {func}`~aesara.function` to define a callable object so that we can push values trough the graph."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 6,
+   "metadata": {},
    "outputs": [],
    "source": [
     "f = aesara.function(inputs=[x, y], outputs=w)"
@@ -268,31 +189,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Now that the graph is compiled, we can push some concrete values:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([0., 1.])"
-      ]
+      "text/plain": "array([0., 1.])"
      },
-     "execution_count": 13,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -303,11 +214,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     ":::{tip}\n",
     "Sometimes we just want to debug, we can use {meth}`~aesara.graph.basic.Variable.eval` for that:\n",
@@ -316,20 +223,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([0., 1.])"
-      ]
+      "text/plain": "array([0., 1.])"
      },
-     "execution_count": 14,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -340,31 +241,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "You can set intermediate values as well"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([0., 1.])"
-      ]
+      "text/plain": "array([0., 1.])"
      },
-     "execution_count": 15,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -375,11 +266,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### Aesara is clever!\n",
     "\n",
@@ -388,12 +275,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -406,11 +289,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 16,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -427,23 +308,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Now let us multiply `b` times `c`. This should result in simply `a`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -458,11 +331,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 17,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -476,23 +347,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "The graph shows the full computation, but once we compile it the operation becomes the identity on `a` as expected."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 12,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -504,11 +367,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 18,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -521,11 +382,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### What is in an Aesara graph?\n",
     "\n",
@@ -536,23 +393,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We can can make these concepts more tangible by explicitly indicating them in the first example from the section above. Let us compute the graph components for the tensor `z`. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 13,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -584,23 +433,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "The following code snippet helps us understand these concepts by going through the computational graph of `w`. The actual code is not as important here, the focus is on the outputs."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -649,23 +490,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Note that this is very similar to the output of {func}`~aesara.dprint` function introduced above."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 15,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -680,11 +513,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 21,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -695,11 +526,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### Graph manipulation 101\n",
     "\n",
@@ -708,20 +535,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "[x, y]"
-      ]
+      "text/plain": "[x, y]"
      },
-     "execution_count": 22,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -733,23 +554,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "As a simple example, let's add an {func}`~aesara.tensor.exp` before the {func}`~aesara.tensor.log` (to get the identity function)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 17,
+   "metadata": {},
    "outputs": [],
    "source": [
     "parent_of_w = w.owner.inputs[0]  # get z tensor\n",
@@ -759,23 +572,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Note that the graph of `w` has actually not changed:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 18,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -790,11 +595,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 24,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -805,23 +608,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "To modify the graph we need to use the {func}`~aesara.clone_replace` function, which *returns a copy of the initial subgraph with the corresponding substitutions.*"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 19,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -837,11 +632,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 25,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -854,31 +647,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Finally, we can test the modified graph by passing some input to the new graph."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 20,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([1.        , 2.71828183])"
-      ]
+      "text/plain": "array([1.        , 2.71828183])"
      },
-     "execution_count": 26,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -889,22 +672,14 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "As expected, the new graph is just the identity function."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     ":::{note}\n",
     "Again, note that `aesara` is clever enough to omit the `exp` and `log` once we compile the function.\n",
@@ -913,12 +688,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 21,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -932,11 +703,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 27,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -949,20 +718,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 22,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([1.        , 2.71828183])"
-      ]
+      "text/plain": "array([1.        , 2.71828183])"
      },
-     "execution_count": 28,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -973,11 +736,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### Aesara RandomVariables\n",
     "\n",
@@ -988,19 +747,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 23,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 576x432 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 576x432 with 1 Axes>",
+      "image/png": "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\n"
      },
      "metadata": {
       "needs_background": "light"
@@ -1018,31 +771,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Now let's try to do it in Aesara."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 24,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "TensorType(float64, ())"
-      ]
+      "text/plain": "TensorType(float64, ())"
      },
-     "execution_count": 30,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1054,30 +797,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Next, we show the graph using {func}`~aesara.dprint`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 25,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "normal_rv{0, (0, 0), floatX, False}.1 [id A] 'y'\n",
-      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x1300F9820>) [id B]\n",
+      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x7F85A64FFA00>) [id B]\n",
       " |TensorConstant{[]} [id C]\n",
       " |TensorConstant{11} [id D]\n",
       " |TensorConstant{0} [id E]\n",
@@ -1086,11 +821,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 31,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1101,11 +834,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "The inputs are always in the following order:\n",
     "1. `rng` shared variable\n",
@@ -1118,31 +847,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We *could* sample by calling {meth}`~aesara.graph.basic.Variable.eval`. on the random variable."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 26,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array(0.30189123)"
-      ]
+      "text/plain": "array(-0.8043385)"
      },
-     "execution_count": 32,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1153,38 +872,30 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Note however that these samples are always the same!"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 27,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Sample 0: 0.30189122572724103\n",
-      "Sample 1: 0.30189122572724103\n",
-      "Sample 2: 0.30189122572724103\n",
-      "Sample 3: 0.30189122572724103\n",
-      "Sample 4: 0.30189122572724103\n",
-      "Sample 5: 0.30189122572724103\n",
-      "Sample 6: 0.30189122572724103\n",
-      "Sample 7: 0.30189122572724103\n",
-      "Sample 8: 0.30189122572724103\n",
-      "Sample 9: 0.30189122572724103\n"
+      "Sample 0: -0.804338501335673\n",
+      "Sample 1: -0.804338501335673\n",
+      "Sample 2: -0.804338501335673\n",
+      "Sample 3: -0.804338501335673\n",
+      "Sample 4: -0.804338501335673\n",
+      "Sample 5: -0.804338501335673\n",
+      "Sample 6: -0.804338501335673\n",
+      "Sample 7: -0.804338501335673\n",
+      "Sample 8: -0.804338501335673\n",
+      "Sample 9: -0.804338501335673\n"
      ]
     }
    ],
@@ -1195,11 +906,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We always get the same samples! This has to do with the random seed step in the graph, i.e. `RandomGeneratorSharedVariable` (we will not go deeper into this subject here). We will show how to generate different samples with `pymc` below."
    ]
@@ -1213,11 +920,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "## PyMC\n",
     "\n",
@@ -1233,19 +936,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 28,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "normal_rv{0, (0, 0), floatX, False}.1 [id A]\n",
-      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x13026D2E0>) [id B]\n",
+      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x7F859E3512A0>) [id B]\n",
       " |TensorConstant{[]} [id C]\n",
       " |TensorConstant{11} [id D]\n",
       " |TensorConstant{0} [id E]\n",
@@ -1254,11 +953,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 34,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1270,49 +967,37 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Observe that `x` is just a normal `RandomVariable` and which is the same as `y` except for the `rng`."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We can try to generate samples by calling {meth}`~aesara.graph.basic.Variable.eval` as above."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 29,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Sample 0: -2.237598162546344\n",
-      "Sample 1: -2.237598162546344\n",
-      "Sample 2: -2.237598162546344\n",
-      "Sample 3: -2.237598162546344\n",
-      "Sample 4: -2.237598162546344\n",
-      "Sample 5: -2.237598162546344\n",
-      "Sample 6: -2.237598162546344\n",
-      "Sample 7: -2.237598162546344\n",
-      "Sample 8: -2.237598162546344\n",
-      "Sample 9: -2.237598162546344\n"
+      "Sample 0: 0.9562139156242165\n",
+      "Sample 1: 0.9562139156242165\n",
+      "Sample 2: 0.9562139156242165\n",
+      "Sample 3: 0.9562139156242165\n",
+      "Sample 4: 0.9562139156242165\n",
+      "Sample 5: 0.9562139156242165\n",
+      "Sample 6: 0.9562139156242165\n",
+      "Sample 7: 0.9562139156242165\n",
+      "Sample 8: 0.9562139156242165\n",
+      "Sample 9: 0.9562139156242165\n"
      ]
     }
    ],
@@ -1323,30 +1008,20 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "As before we get the same value for all iterations. The correct way to generate random samples is using {func}`~pymc.draw`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 30,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 576x432 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 576x432 with 1 Axes>",
+      "image/png": "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\n"
      },
      "metadata": {
       "needs_background": "light"
@@ -1362,65 +1037,47 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Yay! We learned how to sample from a `pymc` distribution!"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### What is going on behind the scenes?"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We can now look into how this is done inside a {class}`~pymc.Model`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 31,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "normal_rv{0, (0, 0), floatX, False}.1 [id A]\n",
-      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x130316580>) [id B]\n",
+      "normal_rv{0, (0, 0), floatX, False}.1 [id A] 'z'\n",
+      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x7F859E193060>) [id B]\n",
       " |TensorConstant{[]} [id C]\n",
       " |TensorConstant{11} [id D]\n",
-      " |TensorConstant{0} [id E]\n",
-      " |TensorConstant{1.0} [id F]\n"
+      " |TensorConstant{(2,) of 0} [id E]\n",
+      " |TensorConstant{[1. 2.]} [id F]\n"
      ]
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 37,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1429,36 +1086,26 @@
     "with pm.Model() as model:\n",
     "    z = pm.Normal(name=\"z\", mu=np.array([0, 0]), sigma=np.array([1, 2]))\n",
     "\n",
-    "aesara.dprint(x)"
+    "aesara.dprint(z)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We are just creating random variables like we saw before, but now registering them in a `pymc` model. To extract the list of random variables we can simply do:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 32,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "[z]"
-      ]
+      "text/plain": "[z ~ N(<constant>, <constant>)]"
      },
-     "execution_count": 38,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1469,19 +1116,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 33,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "normal_rv{0, (0, 0), floatX, False}.1 [id A] 'z'\n",
-      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x130396040>) [id B]\n",
+      " |RandomGeneratorSharedVariable(<Generator(PCG64) at 0x7F859E193060>) [id B]\n",
       " |TensorConstant{[]} [id C]\n",
       " |TensorConstant{11} [id D]\n",
       " |TensorConstant{(2,) of 0} [id E]\n",
@@ -1490,11 +1133,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 39,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1505,38 +1146,30 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "We can try to sample via {meth}`~aesara.graph.basic.Variable.eval` as above and it is no surprise that we are getting the same samples at each iteration."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 34,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Sample 0: [-0.14109248  1.10120293]\n",
-      "Sample 1: [-0.14109248  1.10120293]\n",
-      "Sample 2: [-0.14109248  1.10120293]\n",
-      "Sample 3: [-0.14109248  1.10120293]\n",
-      "Sample 4: [-0.14109248  1.10120293]\n",
-      "Sample 5: [-0.14109248  1.10120293]\n",
-      "Sample 6: [-0.14109248  1.10120293]\n",
-      "Sample 7: [-0.14109248  1.10120293]\n",
-      "Sample 8: [-0.14109248  1.10120293]\n",
-      "Sample 9: [-0.14109248  1.10120293]\n"
+      "Sample 0: [-0.14882183  4.14157407]\n",
+      "Sample 1: [-0.14882183  4.14157407]\n",
+      "Sample 2: [-0.14882183  4.14157407]\n",
+      "Sample 3: [-0.14882183  4.14157407]\n",
+      "Sample 4: [-0.14882183  4.14157407]\n",
+      "Sample 5: [-0.14882183  4.14157407]\n",
+      "Sample 6: [-0.14882183  4.14157407]\n",
+      "Sample 7: [-0.14882183  4.14157407]\n",
+      "Sample 8: [-0.14882183  4.14157407]\n",
+      "Sample 9: [-0.14882183  4.14157407]\n"
      ]
     }
    ],
@@ -1547,38 +1180,30 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Again, the correct way of sampling is via {func}`~pymc.draw`. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 35,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Sample 0: [-0.30763395 -0.03785518]\n",
-      "Sample 1: [ 1.65868277 -2.89168795]\n",
-      "Sample 2: [ 0.60497487 -2.01427486]\n",
-      "Sample 3: [-1.00668317  1.17879995]\n",
-      "Sample 4: [0.31450361 1.08257152]\n",
-      "Sample 5: [ 0.48597109 -4.1494794 ]\n",
-      "Sample 6: [-1.37987128  0.80704246]\n",
-      "Sample 7: [2.49376802 3.16863565]\n",
-      "Sample 8: [0.88427773 1.99857046]\n",
-      "Sample 9: [ 1.01287644 -0.99032698]\n"
+      "Sample 0: [0.43562858 0.2937141 ]\n",
+      "Sample 1: [-0.82913473 -0.45162817]\n",
+      "Sample 2: [-0.39186432  0.84863972]\n",
+      "Sample 3: [-0.9840986  -0.29480585]\n",
+      "Sample 4: [-0.13096991 -0.10632378]\n",
+      "Sample 5: [-0.94007078  3.080421  ]\n",
+      "Sample 6: [-0.32518418  1.52276117]\n",
+      "Sample 7: [-0.21348089  3.09445457]\n",
+      "Sample 8: [-0.62399986 -2.13572382]\n",
+      "Sample 9: [-0.21707549  1.44738996]\n"
      ]
     }
    ],
@@ -1589,19 +1214,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 36,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
+      "text/plain": "<Figure size 576x576 with 1 Axes>",
+      "image/png": "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\n"
      },
      "metadata": {
       "needs_background": "light"
@@ -1618,49 +1237,29 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### Enough with Random Variables, I want to see some (log)probabilities!"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Recall we have defined the following model above:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 37,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/latex": [
-       "$$\n",
-       "            \\begin{array}{rcl}\n",
-       "            \\text{z} &\\sim & \\operatorname{N}(\\text{<constant>},~\\text{<constant>})\n",
-       "            \\end{array}\n",
-       "            $$"
-      ],
-      "text/plain": [
-       "<pymc.model.Model at 0x130120400>"
-      ]
+      "text/plain": "z ~ N(<constant>, <constant>)",
+      "text/latex": "$$\n            \\begin{array}{rcl}\n            \\text{z} &\\sim & \\operatorname{N}(\\text{<constant>},~\\text{<constant>})\n            \\end{array}\n            $$"
      },
-     "execution_count": 43,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1671,23 +1270,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "`pymc` is able to convert `RandomVariable`s to their respective probability functions. One simple way is to use {func}`~pymc.logp`, which takes as first input a RandomVariable, and as second input the value at which the logp is evaluated (we will discuss this in more detail later)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 38,
+   "metadata": {},
    "outputs": [],
    "source": [
     "z_value = at.vector(name=\"z\")\n",
@@ -1696,23 +1287,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "`z_logp` contains the Aesara graph that represents the log-probability of the normal random variable `z`, evaluated at `z_value`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 39,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1747,11 +1330,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 45,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1762,11 +1343,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     ":::{tip}\n",
     "There is also a handy `pymc` function to compute the log cumulative probability of a random variable {func}`~pymc.logcdf`."
@@ -1774,31 +1351,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Observe that, as explained at the beginning, there has been no computation yet. The actual computation is performed after compiling and passing the input. For illustration purposes alone, we will again use the handy {meth}`~aesara.graph.basic.Variable.eval` method."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 40,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([-0.91893853, -1.61208571])"
-      ]
+      "text/plain": "array([-0.91893853, -1.61208571])"
      },
-     "execution_count": 46,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1809,31 +1376,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "This is nothing else than evaluating the log probability of a normal distribution."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 41,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([-0.91893853, -1.61208571])"
-      ]
+      "text/plain": "array([-0.91893853, -1.61208571])"
      },
-     "execution_count": 47,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1844,23 +1401,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "`pymc` models provide some helpful routines to facilitating the conversion of `RandomVariable`s to probability functions. {meth}`~pymc.Model.logp`, for instance can be used to extract the joint probability of all variables in the model:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 42,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -1898,11 +1447,9 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<ipykernel.iostream.OutStream at 0x108833340>"
-      ]
+      "text/plain": "<ipykernel.iostream.OutStream at 0x7f862a141570>"
      },
-     "execution_count": 48,
+     "execution_count": 42,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1913,23 +1460,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Because we only have one variable, this function is equivalent to what we obtained by manually calling `pm.logp` before. We can also use a helper {meth}`~pymc.Model.compile_logp` to return an already compiled Aesara function of the model logp."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 43,
+   "metadata": {},
    "outputs": [],
    "source": [
     "logp_function = model.compile_logp(sum=False)"
@@ -1937,31 +1476,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "This function expects a \"point\" dictionary as input. We could create it ourselves, but just to illustrate another useful {class}`~pymc.Model` method, let's call {meth}`~pymc.Model.initial_point`, which returns the point that most samplers use when deciding where to start sampling."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 44,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "{'z': array([0., 0.])}"
-      ]
+      "text/plain": "{'z': array([0., 0.])}"
      },
-     "execution_count": 50,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1973,20 +1502,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 45,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "[array([-0.91893853, -1.61208571])]"
-      ]
+      "text/plain": "[array([-0.91893853, -1.61208571])]"
      },
-     "execution_count": 51,
+     "execution_count": 45,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1997,11 +1520,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "### What are value variables and why are they important?\n",
     "\n",
@@ -2010,20 +1529,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 46,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "<scipy.stats._distn_infrastructure.rv_frozen at 0x130905790>"
-      ]
+      "text/plain": "<scipy.stats._distn_infrastructure.rv_frozen at 0x7f859d9fedd0>"
      },
-     "execution_count": 52,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2037,20 +1550,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 47,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([-0.01634534,  0.89999837, -0.03039365])"
-      ]
+      "text/plain": "array([ 0.14809949, -1.18242809,  1.34229652])"
      },
-     "execution_count": 53,
+     "execution_count": 47,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2062,20 +1569,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 48,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "-1.7001885332046727"
-      ]
+      "text/plain": "-1.7001885332046727"
      },
-     "execution_count": 54,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2087,23 +1588,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Next, let's look at how these value variables behave in a slightly more complex model."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 49,
+   "metadata": {},
    "outputs": [],
    "source": [
     "with pm.Model() as model_2:\n",
@@ -2114,31 +1607,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Each model RV is related to a \"value variable\":"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 50,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "{mu: mu, sigma: sigma_log__, x: x}"
-      ]
+      "text/plain": "{mu ~ N(0, 2): mu, sigma ~ N**+(0, 3): sigma_log__, x ~ N(mu, sigma): x}"
      },
-     "execution_count": 56,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2149,31 +1632,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Observe that for sigma the associated value is in the *log* scale as in practice we require unbounded values for NUTS sampling."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 51,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "[mu, sigma_log__, x]"
-      ]
+      "text/plain": "[mu, sigma_log__, x]"
      },
-     "execution_count": 57,
+     "execution_count": 51,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2184,31 +1657,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "Now that we know how to extract the model variables, we can compute the element-wise log-probability of the model for specific values."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 52,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "array([ -1.61208571, -11.32440364,   9.08106147])"
-      ]
+      "text/plain": "array([ -1.61208571, -11.32440364,   9.08106147])"
      },
-     "execution_count": 58,
+     "execution_count": 52,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2226,23 +1689,15 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "This equivalent to:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 53,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -2268,11 +1723,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     ":::{Note}\n",
     "For `sigma_log_value` we add the $-10$ term for the `scipy` and `aesara` to match because of the jacobian.\n",
@@ -2281,31 +1732,21 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "As we already saw, we can also use the method {meth}`~pymc.Model.compile_logp` to obtain a compiled aesara function of the model logp, which takes a dictionary of `{value variable name : value}` as inputs:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 54,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "[array(-1.61208571), array(-11.32440364), array(9.08106147)]"
-      ]
+      "text/plain": "[array(-1.61208571), array(-11.32440364), array(9.08106147)]"
      },
-     "execution_count": 60,
+     "execution_count": 54,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2316,22 +1757,14 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "The {class}`~pymc.Model` class also has methods to extract the gradient ({meth}`~pymc.Model.dlogp`) and the hessian ({meth}`~pymc.Model.d2logp`) of the logp."
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "If you want to go deeper into the internals of `aesara` RandomVariables and `pymc` distributions please take a look into the [distribution developer guide](implementing-a-distribution)."
    ]
@@ -2361,9 +1794,9 @@
   },
   "hide_input": false,
   "kernelspec": {
-   "display_name": "Python 3.9.13 ('website_projects-1IZj_WTw')",
+   "name": "pymc",
    "language": "python",
-   "name": "python3"
+   "display_name": "pymc"
   },
   "language_info": {
    "codemirror_mode": {