{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "(model_averaging)=\n", "# Model Averaging\n", "\n", ":::{post} Aug 2024\n", ":tags: model comparison, model averaging\n", ":category: intermediate\n", ":author: Osvaldo Martin\n", ":::" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "papermill": { "duration": 4.910288, "end_time": "2020-11-29T12:13:07.788552", "exception": false, "start_time": "2020-11-29T12:13:02.878264", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running on PyMC v5.16.2+24.g799c98f41\n" ] } ], "source": [ "import os\n", "\n", "import arviz as az\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "import pymc as pm\n", "\n", "print(f\"Running on PyMC v{pm.__version__}\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "papermill": { "duration": 0.058811, "end_time": "2020-11-29T12:13:07.895012", "exception": false, "start_time": "2020-11-29T12:13:07.836201", "status": "completed" }, "tags": [] }, "outputs": [], "source": [ "rng = np.random.seed(2741)\n", "az.style.use(\"arviz-darkgrid\")" ] }, { "cell_type": "markdown", "metadata": { "papermill": { "duration": 0.068882, "end_time": "2020-11-29T12:13:08.020372", "exception": false, "start_time": "2020-11-29T12:13:07.951490", "status": "completed" }, "tags": [] }, "source": [ "When confronted with more than one model we have several options. One of them is to perform model selection as exemplified by the PyMC examples {ref}`pymc:model_comparison` and the {ref}`GLM-model-selection`, usually is a good idea to also include posterior predictive checks in order to decide which model to keep. Discarding all models except one is equivalent to affirm that, among the evaluated models, one is correct (under some criteria) with probability 1 and the rest are incorrect. In most cases this will be an overstatment that ignores the uncertainty we have in our models. This is somewhat similar to computing the full posterior and then just keeping a point-estimate like the posterior mean; we may become overconfident of what we really know. You can also browse the {doc}`blog/tag/model-comparison` tag to find related posts. \n", "\n", "An alternative to this dilema is to perform model selection but to acknoledge the models we discared. If the number of models are not that large this can be part of a technical discussion on a paper, presentation, thesis, and so on. If the audience is not technical enough, this may not be a good idea.\n", "\n", "Yet another alternative, the topic of this example, is to perform model averaging. The idea is to weight each model by its merit and generate predictions from each model, proportional to those weights. There are several ways to do this, including the three methods that will be briefly discussed in this notebook. You will find a more thorough explanation in the work by {cite:t}`Yao_2018` and {cite:t}`Yao_2022`. \n", "\n", "\n", "## Pseudo Bayesian model averaging\n", "\n", "Bayesian models can be weighted by their marginal likelihood, which is known as Bayesian Model Averaging. While this is theoretically appealing, it is problematic in practice: on the one hand the marginal likelihood is highly sensitive to the specification of the prior, in a way that parameter estimation is not, and on the other, computing the marginal likelihood is usually a challenging task. Additionally, Bayesian model averaging is flawed in the $\\mathcal{M}$-open setting in which the true data-generating process is not one of the candidate models being fit {cite:t}`Yao_2018`. A more robust approach is to compute the expected log pointwise predictive density (ELPD).\n", "\n", "$$\n", "\\sum_i^N \\log \\int \\ p(y_i \\mid \\theta) \\; p(\\theta \\mid y) d\\theta\n", "$$\n", "\n", "where $N$ is the number of data points, $y_i$ is the i-th data point, $\\theta$ are the parameters of the model, $p(y_i \\mid \\theta)$ is the likelihood of the i-th data point given the parameters, and $p(\\theta \\mid y)$ is the posterior distribution.\n", "\n", "Once we have computed the ELPD for each model we can compute weights by doing\n", "\n", "$$w_i = \\frac {e^{dELPD_i}} {\\sum_j^M e^{dELPD_i}}$$\n", "\n", "Where $dELPD_i$ is the difference between the model with the best ELPD and the i-th model.\n", "\n", "This approach is called pseudo Bayesian model averaging, or Akaike-like weighting and is an heuristic to compute the relative probability of each model (given a fixed set of models). Note that we exponetiate to \"revert\" the effect of the logarithm in the ELPD formula and the denominator is a normalization term to ensure that the weights sum up to one. With a pinch of salt, we can interpret these weights as the probability of each model explaining the data.\n", "\n", "So far so good, but the ELPD is a theoretical quantity, and in practice we need to approximate it. To do so ArviZ offers two methods\n", "\n", "* WAIC, Widely Applicable Information Criterion\n", "* LOO, Pareto-Smooth-Leave-One-Out-Cross-Validation.\n", "\n", "Both requiere and InferenceData with the log-likelihood group and are equally fast to compute. We recommend using LOO because it has better practical properties, and better diagnostics (so we known when we are having issues with the ELPD estimation).\n", "\n", "## Pseudo Bayesian model averaging with Bayesian Bootstrapping\n", "\n", "The above formula for computing weights is a nice and simple approach, but with one major caveat: it does not take into account the uncertainty in the computation of the ELPD. We could compute the standard error of the ELPD value (assuming a Gaussian approximation) and modify the above formula accordingly. Or we can do something more robust, like using a [Bayesian Bootstrapping](http://www.sumsar.net/blog/2015/04/the-non-parametric-bootstrap-as-a-bayesian-model/) to estimate, and incorporate this uncertainty.\n", "\n", "## Stacking\n", "\n", "The third approach we will discuss is known as _stacking of predictive distributions_ by {cite:t}`Yao_2018`. We want to combine several models in a metamodel in order to minimize the divergence between the meta-model and the _true_ generating model. When using a logarithmic scoring rule this is equivalent to:\n", "\n", "$$\\max_{w} \\frac{1}{n} \\sum_{i=1}^{n}log\\sum_{k=1}^{K} w_k p(y_i \\mid y_{-i}, M_k)$$\n", "\n", "Where $n$ is the number of data points and $K$ the number of models. To enforce a solution we constrain $w$ to be $w_k \\ge 0$ and $\\sum_{k=1}^{K} w_k = 1$. \n", "\n", "The quantity $p(y_i \\mid y_{-i}, M_k)$ is the leave-one-out predictive distribution for the $M_k$ model. Computing it requires fitting each model $n$ times, each time leaving out one data point. Fortunately, this is exactly what LOO approximates in a very efficient way. So we can use LOO and stacking together. To be fair, we can also use WAIC, even when WAIC approximates the ELPD in a different way.\n", "\n", "## Weighted posterior predictive samples\n", "\n", "Once we have computed the weights, using any of the above 3 methods, we can use them to get weighted posterior predictive samples. We will illustrate how to do it using the body fat dataset {cite}`penrose1985`. This dataset has measurements from 251 individuals, including their weight, height, the circumference of the abdomen, the circumference of the wrist etc. Our purpose is to predict the percentage of body fat, as estimated by the siri variable, also available from the dataset.\n", "\n", "Let's start by loading the data" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "papermill": { "duration": 1.114901, "end_time": "2020-11-29T12:13:09.196103", "exception": false, "start_time": "2020-11-29T12:13:08.081202", "status": "completed" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
siriageweightheightneckchestabdomenhipthighkneeanklebicepsforearmwrist
012.32370.117236.293.185.294.559.037.321.932.027.417.1
16.12278.818438.593.683.098.758.737.323.430.528.918.2
225.32270.016834.095.887.999.259.638.924.028.825.216.6
310.42684.018437.4101.886.4101.260.137.322.832.429.418.2
428.72483.818134.497.3100.0101.963.242.224.032.227.717.7
\n", "
" ], "text/plain": [ " siri age weight height neck chest abdomen hip thigh knee ankle \\\n", "0 12.3 23 70.1 172 36.2 93.1 85.2 94.5 59.0 37.3 21.9 \n", "1 6.1 22 78.8 184 38.5 93.6 83.0 98.7 58.7 37.3 23.4 \n", "2 25.3 22 70.0 168 34.0 95.8 87.9 99.2 59.6 38.9 24.0 \n", "3 10.4 26 84.0 184 37.4 101.8 86.4 101.2 60.1 37.3 22.8 \n", "4 28.7 24 83.8 181 34.4 97.3 100.0 101.9 63.2 42.2 24.0 \n", "\n", " biceps forearm wrist \n", "0 32.0 27.4 17.1 \n", "1 30.5 28.9 18.2 \n", "2 28.8 25.2 16.6 \n", "3 32.4 29.4 18.2 \n", "4 32.2 27.7 17.7 " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "try:\n", " d = pd.read_csv(os.path.join(\"..\", \"data\", \"body_fat.csv\"))\n", "except FileNotFoundError:\n", " d = pd.read_csv(pm.get_data(\"body_fat.csv\"))\n", "\n", "d.head()" ] }, { "cell_type": "markdown", "metadata": { "papermill": { "duration": 0.048113, "end_time": "2020-11-29T12:13:09.292526", "exception": false, "start_time": "2020-11-29T12:13:09.244413", "status": "completed" }, "tags": [] }, "source": [ "Now that we have the data we are going to build two models, both are simple linear regressions the difference is that for the first one we are going to use the variables `abdomen`, and for the second one we are going to use the variables `wrist`, `height` and `weight`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 4 jobs)\n", "NUTS: [alpha, beta, sigma]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "534a7369174d40bcb342c3ee266992a6", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n" ], "text/plain": [ "\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 7 seconds.\n", "Sampling: [siri]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "da2c4d9bc89345c2834b03d04dead94b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n" ], "text/plain": [ "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with pm.Model() as model_0:\n", " alpha = pm.Normal(\"alpha\", mu=0, sigma=1)\n", " beta = pm.Normal(\"beta\", mu=0, sigma=1)\n", " sigma = pm.HalfNormal(\"sigma\", 5)\n", "\n", " mu = alpha + beta * d[\"abdomen\"]\n", "\n", " siri = pm.Normal(\"siri\", mu=mu, sigma=sigma, observed=d[\"siri\"])\n", "\n", " idata_0 = pm.sample(idata_kwargs={\"log_likelihood\": True}, random_seed=rng)\n", " pm.sample_posterior_predictive(idata_0, extend_inferencedata=True, random_seed=rng)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (4 chains in 4 jobs)\n", "NUTS: [alpha, beta, sigma]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "213552d5ddeb4dcb9b1758e941e77887", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n" ], "text/plain": [ "\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 36 seconds.\n", "Sampling: [siri]\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "91f277f5f79f4e48a6f6b0df6d7b52df", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Output()" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "
\n"
      ],
      "text/plain": []
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "
\n",
       "
\n" ], "text/plain": [ "\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with pm.Model() as model_1:\n", " alpha = pm.Normal(\"alpha\", mu=0, sigma=1)\n", " beta = pm.Normal(\"beta\", mu=0, sigma=1, shape=3)\n", " sigma = pm.HalfNormal(\"sigma\", 5)\n", "\n", " mu = alpha + pm.math.dot(beta, d[[\"wrist\", \"height\", \"weight\"]].T)\n", "\n", " siri = pm.Normal(\"siri\", mu=mu, sigma=sigma, observed=d[\"siri\"])\n", "\n", " idata_1 = pm.sample(idata_kwargs={\"log_likelihood\": True}, random_seed=rng)\n", " pm.sample_posterior_predictive(idata_1, extend_inferencedata=True, random_seed=rng)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before LOO (or WAIC) to compare and or average models we should check that we do not have sampling issues and posterior predictive checks are resonable. For the sake of brevity we are going to skip these steps and instead jump to the model averaging.\n", "\n", "First we need to call `az.compare` to compute the LOO values for each model and the weights using `stacking`. These are the default options, if you want to perform pseudo Bayesian model averaging you can use the `method='BB-pseudo-BMA'` that includes the Bayesian Bootstrap estimation of the uncertainty in the ELPD.\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
rankelpd_loop_looelpd_diffweightsedsewarningscale
model_10-817.2168953.6267040.0000000.63923610.4963420.000000Falselog
model_01-825.3449781.8329098.1280830.3607649.9707688.698358Falselog
\n", "
" ], "text/plain": [ " rank elpd_loo p_loo elpd_diff weight se dse \\\n", "model_1 0 -817.216895 3.626704 0.000000 0.639236 10.496342 0.000000 \n", "model_0 1 -825.344978 1.832909 8.128083 0.360764 9.970768 8.698358 \n", "\n", " warning scale \n", "model_1 False log \n", "model_0 False log " ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model_dict = dict(zip([\"model_0\", \"model_1\"], [idata_0, idata_1]))\n", "comp = az.compare(model_dict)\n", "comp" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see from the column `weight`, that `model_1` has a weight of $\\approx 0.6$ and `model_2` has a weight $\\approx 0.4$. To use this weights to generate posterior predictive samples we can use the `az.weighted_posterior` function. This function takes the InferenceData objects and the weights and returns a new InferenceData object." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "
\n", "
\n", "
arviz.InferenceData
\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Inference data with groups:\n", "\t> posterior_predictive\n", "\t> observed_data" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ppc_w = az.weight_predictions(\n", " [model_dict[name] for name in comp.index],\n", " weights=comp.weight,\n", ")\n", "ppc_w" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the following plot we can see that the avearged model is a combination of the two models." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "az.plot_kde(\n", " idata_0.posterior_predictive[\"siri\"].values,\n", " plot_kwargs={\"color\": \"C0\", \"linestyle\": \"--\"},\n", " label=\"model_0\",\n", ")\n", "az.plot_kde(\n", " idata_1.posterior_predictive[\"siri\"].values,\n", " plot_kwargs={\"color\": \"C0\", \"linestyle\": \"--\"},\n", " label=\"model_1\",\n", ")\n", "az.plot_kde(\n", " ppc_w.posterior_predictive[\"siri\"].values,\n", " plot_kwargs={\"color\": \"C1\", \"linewidth\": 2},\n", " label=\"average_model\",\n", ");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## To do or not to do?\n", "\n", "Model averaging is a good idea when you want to improve the robustness of your predictions. Usually a combinations of models will have better predictive performance than any single model. This is specially true when the models are complementary. Something we have not explored in this example is to assign weights to models in a way that they vary for different parts of the data. This can be done as discussed in {cite:t}`Yao_2022`.\n", "\n", "When not do to model averaging? Many times we can create new models that effectively work as averages of other models. For instance in this example we could have created a new model that includes all the variables. That's actually a very sensible thing to do. Notice that if a model excludes a variable thats equivalent to setting the coefficient of that variable to zero. If we average a model with the variable and without it, it's like setting the coefficient to a value between zero and the value of the coefficient in the model that includes the variable. This is a very simple example, but the same reasoning applies to more complex models.\n", "\n", "Hierarchical models are another example were we build a continous version of a model instead of dealing with discrete versions. A toy example is to imagine that we have a coin and we want to estimated its degree of bias, a number between 0 and 1 having a 0.5 equal chance of head and tails (fair coin). We could think of two separate models: one with a prior biased towards heads and one with a prior biased towards towards tails. We could fit both separate models and then average them. An alternative is to build a hierarchical model to estimate the prior distribution. Instead of contemplating two discrete models, we would be computing a continuous model that considers the discrete ones as particular cases. Which approach is better? That depends on our concrete problem. Do we have good reasons to think about two discrete models, or is our problem better represented with a continuous bigger model?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Authors\n", "\n", "* Authored by Osvaldo Martin in June 2017 ([pymc#2273](https://github.com/pymc-devs/pymc/pull/2273))\n", "* Updated by Osvaldo Martin in December 2017 ([pymc#2741](https://github.com/pymc-devs/pymc/pull/2741))\n", "* Updated by Marco Gorelli in November 2020 ([pymc#4271](https://github.com/pymc-devs/pymc/pull/4271))\n", "* Moved from pymc to pymc-examples repo in December 2020 ([pymc-examples#8](https://github.com/pymc-devs/pymc-examples/pull/8))\n", "* Updated by Raul Maldonado in February 2021 ([pymc#25](https://github.com/pymc-devs/pymc-examples/pull/25))\n", "* Updated Markdown and styling by @reshamas in August 2022, ([pymc-examples#414](https://github.com/pymc-devs/pymc-examples/pull/414))\n", "* Updated notebook to use pymc 5 by Adrien Porter in November 2023 \n", "* Updated by Osvaldo Martin in August 2024 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", ":::{bibliography}\n", ":filter: docname in docnames\n", ":::" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Watermark" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "papermill": { "duration": 0.127595, "end_time": "2020-11-29T12:16:06.392237", "exception": false, "start_time": "2020-11-29T12:16:06.264642", "status": "completed" }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Last updated: Fri Aug 23 2024\n", "\n", "Python implementation: CPython\n", "Python version : 3.11.5\n", "IPython version : 8.16.1\n", "\n", "arviz : 0.20.0.dev0\n", "pandas : 2.1.2\n", "pymc : 5.16.2+24.g799c98f41\n", "numpy : 1.24.4\n", "matplotlib: 3.8.4\n", "\n", "Watermark: 2.4.3\n", "\n" ] } ], "source": [ "%load_ext watermark\n", "%watermark -n -u -v -iv -w" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ":::{include} ../page_footer.md\n", ":::" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5" } }, "nbformat": 4, "nbformat_minor": 4 }