{ "cells": [ { "cell_type": "markdown", "id": "bc1f69aa-913d-49fa-8e20-58f953301851", "metadata": {}, "source": [ "(model_configuration)=\n", "# Model Configuration\n", "\n", "This goes over the model configuration\n", "\n", "## Setup" ] }, { "cell_type": "code", "execution_count": 1, "id": "9d6bc077-24d1-47de-8542-5497ade670e3", "metadata": {}, "outputs": [], "source": [ "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", "from pymc_marketing.model_config import ModelConfigError, parse_model_config\n", "from pymc_marketing.prior import Prior\n", "\n", "az.style.use(\"arviz-darkgrid\")\n", "plt.rcParams[\"figure.figsize\"] = [12, 7]\n", "plt.rcParams[\"figure.dpi\"] = 100" ] }, { "cell_type": "code", "execution_count": 2, "id": "6fa99350-cc39-4ef9-9c9a-f6e0f7091636", "metadata": {}, "outputs": [], "source": [ "seed = sum(map(ord, \"Create priors to reflect your marketing beliefs\"))\n", "rng = np.random.default_rng(seed)" ] }, { "cell_type": "markdown", "id": "a5f28af2-a8a2-4046-ad65-940464862424", "metadata": {}, "source": [ "## Prior Distributions\n", "\n", "The `Prior` class is our way to expression distributions and relationships between them.\n", "\n", "### Basic Usage\n", "\n", "Every prior will need a distribution name that comes from `PyMC`. View the full list in the documentation [here](https://www.pymc.io/projects/docs/en/stable/api/distributions.html)." ] }, { "cell_type": "code", "execution_count": 3, "id": "34815050-4f1b-4345-b31b-466fb357a974", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\")" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "scalar_distribution = Prior(\"Normal\")\n", "scalar_distribution" ] }, { "cell_type": "markdown", "id": "b76493fe-48a1-472e-9c8a-fbf632d89baf", "metadata": {}, "source": [ "If not, then an exception will be raised." ] }, { "cell_type": "code", "execution_count": 4, "id": "06314bd5-ebce-4c41-b2c5-b99143c13192", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PyMC doesn't have a distribution of name 'UnknownDistribution'\n" ] } ], "source": [ "try:\n", " Prior(\"UnknownDistribution\")\n", "except Exception as e:\n", " print(e)" ] }, { "cell_type": "markdown", "id": "d76c8fbd-5a22-408d-af96-c9a0ae712da5", "metadata": {}, "source": [ "Specific parameters can be passed as **keyword arguments** but are not required if the `PyMC` distribution has defaults." ] }, { "cell_type": "code", "execution_count": 5, "id": "d12e116e-32f4-4f15-a9ee-4d6a0472590c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", mu=0, sigma=3.5)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "scalar_distribution = Prior(\"Normal\", mu=0, sigma=3.5)\n", "scalar_distribution" ] }, { "cell_type": "markdown", "id": "3b46a0bd-d178-4afc-9f5e-3dcf19170e7e", "metadata": {}, "source": [ "There will be a check at initialization against the `PyMC` distribution." ] }, { "cell_type": "code", "execution_count": 6, "id": "38a7db8f-9cc0-4e5b-8c64-c04415b0f35a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Parameters {'b', 'mu'} are not a subset of the pymc distribution parameters {'mu', 'tau', 'sigma'}\n" ] } ], "source": [ "try:\n", " Prior(\"Normal\", mu=0, b=1)\n", "except Exception as e:\n", " print(e)" ] }, { "cell_type": "markdown", "id": "e4bb33ab-9045-4701-9daa-eaa3b4b6d80c", "metadata": {}, "source": [ "However, there are some limitations to that. Take this invalid parameterization below:" ] }, { "cell_type": "code", "execution_count": 7, "id": "a8dcb6f8-1357-4de4-b5d5-a30ab2c48e5b", "metadata": {}, "outputs": [], "source": [ "invalid_distribution = Prior(\"Normal\", mu=1, sigma=1, tau=2)" ] }, { "cell_type": "markdown", "id": "660cb88e-3693-43fa-819e-866cd06aba81", "metadata": {}, "source": [ "The `create_variable` method is used to make variables from this distribution and it isn't until then that there is an error." ] }, { "cell_type": "code", "execution_count": 8, "id": "5e1df586-c4d2-4ac0-9a27-cc3313a0005b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Can't pass both tau and sigma\n" ] } ], "source": [ "with pm.Model():\n", " try:\n", " invalid_distribution.create_variable(\"mu\")\n", " except Exception as e:\n", " print(e)" ] }, { "cell_type": "markdown", "id": "9db15fc8-86ac-4a4f-94f2-54bbe7e6fc1e", "metadata": {}, "source": [ "This goes for incorrect values as well!" ] }, { "cell_type": "code", "execution_count": 9, "id": "bb04847a-0500-4597-9fbe-bb772607d4de", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", mu=1, sigma=-1)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "invalid_distribution = Prior(\"Normal\", mu=1, sigma=-1)\n", "invalid_distribution" ] }, { "cell_type": "markdown", "id": "5de45592-94fb-4bb8-976f-48edf4244a57", "metadata": {}, "source": [ "The `dims` parameter are used to express the dimensions of the distribution. This variable is not part of a model so the values are not reflected with the distribution itself." ] }, { "cell_type": "code", "execution_count": 10, "id": "925e49bf-97f3-4fa8-863e-2655abc65e82", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", dims=\"channel\")" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector_distribution = Prior(\"Normal\", dims=\"channel\")\n", "vector_distribution" ] }, { "cell_type": "markdown", "id": "56f329cd-c5fc-44c2-9c27-07d33fe9697c", "metadata": {}, "source": [ "If there are dimensions, then the coords need to exist in the larger model. But they exist separately and can defined in advance.\n", "\n", "```{tip}\n", "Each `Prior` instance is just instructions to create a variable, so they can be used multiple times!\n", "```" ] }, { "cell_type": "code", "execution_count": 11, "id": "ad58dacf-9f56-47f9-b5ca-6678f27d5856", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (2)\n", "\n", "channel (2)\n", "\n", "\n", "\n", "alpha\n", "\n", "alpha\n", "~\n", "Normal\n", "\n", "\n", "\n", "beta\n", "\n", "beta\n", "~\n", "Normal\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "coords = {\"channel\": [\"C1\", \"C2\"]}\n", "with pm.Model(coords=coords) as model:\n", " alpha = vector_distribution.create_variable(\"alpha\")\n", " beta = vector_distribution.create_variable(\"beta\")\n", "\n", "pm.model_to_graphviz(model)" ] }, { "cell_type": "markdown", "id": "27f9583f-b676-4ac2-85a5-d522815de5e3", "metadata": {}, "source": [ "If the coords were not specified then this would cause a PyMC error." ] }, { "cell_type": "code", "execution_count": 12, "id": "76a89202-7f68-4e89-a77a-ae917b1b3573", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\"Dimensions {'channel'} are unknown to the model and cannot be used to specify a `shape`.\"\n" ] } ], "source": [ "with pm.Model() as model:\n", " try:\n", " vector_distribution.create_variable(\"var\")\n", " except Exception as e:\n", " print(e)" ] }, { "cell_type": "markdown", "id": "b1000cc0-2087-48b0-a276-f8921f5db750", "metadata": {}, "source": [ "The variables can get arbitrarily large as well by providing additional dims in a tuple." ] }, { "cell_type": "code", "execution_count": 13, "id": "26101b33-78b3-47fc-996f-140660efb1c9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", dims=(\"channel\", \"geo\"))" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix_distribution = Prior(\"Normal\", dims=(\"channel\", \"geo\"))\n", "matrix_distribution" ] }, { "cell_type": "code", "execution_count": 14, "id": "d129b86f-80ac-473b-b815-9a7ef733ab5d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", dims=(\"channel\", \"geo\", \"store\"))" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tensor_distribution = Prior(\"Normal\", dims=(\"channel\", \"geo\", \"store\"))\n", "tensor_distribution" ] }, { "cell_type": "markdown", "id": "15d51049-02e6-42e1-a31c-942a855347fb", "metadata": {}, "source": [ "### Hierarchical Variables\n", "\n", "Hierarchical variables can be defined by using distributions as the parameters of another distribution. The parent distributions will usually have a larger dimensionality than each of the parameters." ] }, { "cell_type": "code", "execution_count": 15, "id": "5620b88f-5137-4f4b-8ffb-f7362deaea85", "metadata": {}, "outputs": [], "source": [ "hierarchical_variable = Prior(\n", " \"Normal\",\n", " mu=Prior(\"Normal\"),\n", " sigma=Prior(\"HalfNormal\"),\n", " dims=\"channel\",\n", ")" ] }, { "cell_type": "markdown", "id": "32c14b21-66b0-4948-9804-870c25876cbe", "metadata": {}, "source": [ "We can use the `to_graph` method to create visualize the variable with dummy coordinates.\n", "\n", "```{note}\n", "No need to worry about variable naming! The child parameters will all be automatically named based on the parent.\n", "```" ] }, { "cell_type": "code", "execution_count": 16, "id": "e830baac-08fd-492a-ae65-0f6aa36debf9", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "\n", "var_mu\n", "\n", "var_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma\n", "\n", "var_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_sigma->var\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hierarchical_variable.to_graph()" ] }, { "cell_type": "markdown", "id": "b80a4e49-bb8c-4e4d-b533-c00ab150d886", "metadata": {}, "source": [ "```{warning}\n", "The validity of the parameter values will not be checked. \n", "```\n", "\n", "There can be negative sigma parameter in a Normal distribution whether that comes from value or another distribution!" ] }, { "cell_type": "code", "execution_count": 17, "id": "b82d2483-1064-4014-a0c5-498f95ab6b0d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", mu=1, sigma=-1)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Prior(\"Normal\", mu=1, sigma=-1)" ] }, { "cell_type": "code", "execution_count": 18, "id": "3062face-a9c6-446d-8c93-91b99af18059", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", sigma=Prior(\"Normal\"))" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Prior(\"Normal\", sigma=Prior(\"Normal\"))" ] }, { "cell_type": "markdown", "id": "d0d12fd8-07ef-4fcc-816f-cabd6667c1dc", "metadata": {}, "source": [ "```{tip}\n", "Model reparamterizations can help with model convergence depending on the model posterior!\n", "```\n", "\n", "For Normal distribution, the common non-centered parameterization is supported with the `centered` flag." ] }, { "cell_type": "code", "execution_count": 19, "id": "81cee492-654b-4bbb-94b7-25bc87f7dca1", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_offset\n", "\n", "var_offset\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_offset->var\n", "\n", "\n", "\n", "\n", "\n", "var_mu\n", "\n", "var_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma\n", "\n", "var_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_sigma->var\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "non_centered_hierarchical_variable = Prior(\n", " \"Normal\",\n", " mu=Prior(\"Normal\"),\n", " sigma=Prior(\"HalfNormal\"),\n", " dims=\"channel\",\n", " # Flag for non-centered\n", " centered=False,\n", ")\n", "non_centered_hierarchical_variable.to_graph()" ] }, { "cell_type": "markdown", "id": "003ba849-188c-47ac-98c0-248f5c5a08c3", "metadata": {}, "source": [ "Other distributions can be hierarchical as well. Just use distributions for parameters of a parent distribution. For instance, the Beta distribution has two positive parameters, `alpha` and `beta` which can be reflect as HalfNormal distributions." ] }, { "cell_type": "code", "execution_count": 20, "id": "04bf7a16-89a5-4ef7-865e-aab5fe576ca6", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "\n", "var_alpha\n", "\n", "var_alpha\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Beta\n", "\n", "\n", "\n", "var_alpha->var\n", "\n", "\n", "\n", "\n", "\n", "var_beta\n", "\n", "var_beta\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_beta->var\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zero_to_one_variable = Prior(\n", " \"Beta\",\n", " alpha=Prior(\"HalfNormal\"),\n", " beta=Prior(\"HalfNormal\"),\n", " dims=\"channel\",\n", ")\n", "zero_to_one_variable.to_graph()" ] }, { "cell_type": "markdown", "id": "485d6608-228c-491b-93ec-0af713508a25", "metadata": {}, "source": [ "### Transformations\n", "\n", "The `transform` variable can be used for any of the distributions to change its domain.\n", "\n", "These transformations will be taken from `pytensor.tensor` or `pm.math` in that order.\n", "\n", "Below is a non-centered hierarchical Normal distribution that is put through a sigmoid function in order to change the domain to (0, 1)." ] }, { "cell_type": "code", "execution_count": 21, "id": "33529f87-e8e0-471d-8a09-3c7df6b9dcaa", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_raw_offset\n", "\n", "var_raw_offset\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_raw\n", "\n", "var_raw\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_raw_offset->var_raw\n", "\n", "\n", "\n", "\n", "\n", "var_raw->var\n", "\n", "\n", "\n", "\n", "\n", "var_raw_sigma\n", "\n", "var_raw_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_raw_sigma->var_raw\n", "\n", "\n", "\n", "\n", "\n", "var_raw_mu\n", "\n", "var_raw_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_raw_mu->var_raw\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hierarchical_zero_to_one_distribution = Prior(\n", " \"Normal\",\n", " mu=Prior(\"Normal\"),\n", " sigma=Prior(\"HalfNormal\"),\n", " dims=\"channel\",\n", " centered=False,\n", " transform=\"sigmoid\",\n", ")\n", "hierarchical_zero_to_one_distribution.to_graph()" ] }, { "cell_type": "markdown", "id": "ee2270a5-2c73-4464-b924-59d01133dc5d", "metadata": {}, "source": [ "### Prior Visualization\n", "\n", "For scalar distributions, make use of the `preliz` attribute of the model in order to visualize. \n", "\n", "```{tip}\n", "Defaults for the parameters will have to be provided or there will be an error.\n", "```" ] }, { "cell_type": "code", "execution_count": 22, "id": "68ac9293-3d2c-4797-81ed-a50171c7f384", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "beta_distribution = Prior(\"Beta\", alpha=1, beta=4)\n", "\n", "beta_distribution.preliz.plot_pdf();" ] }, { "cell_type": "markdown", "id": "d1a6d281-9646-48e1-ab09-6e9de21e9c11", "metadata": {}, "source": [ "```{tip}\n", "Using the `constrain` method can help hone in on a prior. It is a wrapper around the ever-so-helpful [`find_constrained_prior` function](https://www.pymc.io/projects/docs/en/stable/api/generated/pymc.find_constrained_prior.html). The `init_guess` is taken to be the parameters of the instance distribution.\n", "```" ] }, { "cell_type": "code", "execution_count": 23, "id": "6a02cdb4-9fe9-4eb5-97a3-91fd7abf1835", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Prior(\"Normal\", mu=5.000013661179942, sigma=0.5102135210258302)" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "constrained_distribution = Prior(\"Normal\", mu=5, sigma=1).constrain(lower=4, upper=6)\n", "constrained_distribution" ] }, { "cell_type": "markdown", "id": "007646bd-61f4-4a2d-8400-14c36e08f289", "metadata": {}, "source": [ "For more complicated distributions, consider using the `sample_prior` method in order to access the prior.\n", "\n", "```{note}\n", "Any coordinates will have to be passed like in `pm.Model`.\n", "```" ] }, { "cell_type": "code", "execution_count": 24, "id": "8c2b4ea7-c33d-4d86-a7f8-18434bd0a298", "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Sampling: [var_raw_mu, var_raw_offset, var_raw_sigma_raw]\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 40kB\n",
       "Dimensions:            (chain: 1, draw: 500, channel: 2)\n",
       "Coordinates:\n",
       "  * chain              (chain) int64 8B 0\n",
       "  * draw               (draw) int64 4kB 0 1 2 3 4 5 ... 494 495 496 497 498 499\n",
       "  * channel            (channel) <U2 16B 'C1' 'C2'\n",
       "Data variables:\n",
       "    var_raw_offset     (chain, draw, channel) float64 8kB -0.4456 ... 0.2922\n",
       "    var_raw_sigma      (chain, draw) float64 4kB 0.3459 0.4046 ... 0.436 0.3669\n",
       "    var_raw_sigma_raw  (chain, draw) float64 4kB -1.062 -0.905 ... -1.003\n",
       "    var                (chain, draw, channel) float64 8kB 0.336 ... 0.1463\n",
       "    var_raw            (chain, draw, channel) float64 8kB -0.6811 ... -1.764\n",
       "    var_raw_mu         (chain, draw) float64 4kB -0.527 1.038 ... -1.258 -1.871\n",
       "Attributes:\n",
       "    created_at:                 2024-07-01T15:12:27.403724\n",
       "    arviz_version:              0.17.1\n",
       "    inference_library:          pymc\n",
       "    inference_library_version:  5.14.0
" ], "text/plain": [ " Size: 40kB\n", "Dimensions: (chain: 1, draw: 500, channel: 2)\n", "Coordinates:\n", " * chain (chain) int64 8B 0\n", " * draw (draw) int64 4kB 0 1 2 3 4 5 ... 494 495 496 497 498 499\n", " * channel (channel) " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "bins = np.arange(0, 1.1, 0.1)\n", "prior[\"var\"].to_series().unstack().hist(bins=bins, edgecolor=\"black\")\n", "plt.gcf().suptitle(\"Marginal distributions of the two channels\");" ] }, { "cell_type": "markdown", "id": "22c8037e-4168-443b-b1b5-150d73dd4129", "metadata": {}, "source": [ "Use any workflow to make sense of the prior distribution! For instance, the joint distribution which shows these two channels are correlated due to the hierarchical generation." ] }, { "cell_type": "code", "execution_count": 26, "id": "c9911821-e9c3-4607-b53e-78c086c6a89c", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_correlation(df: pd.DataFrame, x: str = \"C1\", y: str = \"C2\") -> plt.Axes:\n", " corr = df.loc[:, [x, y]].corr().iloc[0, 1]\n", " title = f\"Joint distribution between {x} and {y} ({corr = :.3f})\"\n", " return df.plot.scatter(x=x, y=y, title=title)\n", "\n", "\n", "ax = prior[\"var\"].to_series().unstack().pipe(plot_correlation)\n", "padding = 0.025\n", "bounds = (0 - padding, 1 + padding)\n", "ax.set(xlim=bounds, ylim=bounds);" ] }, { "cell_type": "markdown", "id": "90a9d504-6118-4fb9-a21b-7e01d8e5b5e8", "metadata": {}, "source": [ "### Automatic Broadcasting\n", "\n", "The broadcasting of the dims will be handled automatically.\n", "\n", "For instance, the `mu` of the variable needs to be transposed in order to work with (\"channel\", \"geo\") dims.\n", "\n", "With all this functionality, we can see that the prior distributions can become quite expressive!" ] }, { "cell_type": "code", "execution_count": 27, "id": "078a2501-0e82-4551-b01a-042450e36ddb", "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "clustergeo (1)\n", "\n", "geo (1)\n", "\n", "\n", "clusterchannel (1) x geo (1)\n", "\n", "channel (1) x geo (1)\n", "\n", "\n", "\n", "var_sigma_raw_sigma\n", "\n", "var_sigma_raw_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_sigma_raw\n", "\n", "var_sigma_raw\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw_sigma->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_sigma\n", "\n", "var_mu_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_mu\n", "\n", "var_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_sigma->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_mu\n", "\n", "var_sigma_raw_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_mu->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_mu\n", "\n", "var_mu_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_mu->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma\n", "\n", "var_sigma\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw->var_sigma\n", "\n", "\n", "\n", "\n", "\n", "var_sigma->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_offset\n", "\n", "var_sigma_raw_offset\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_offset->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def create_2d_variable(mu_dims, sigma_dims) -> Prior:\n", " mu = Prior(\n", " \"Normal\",\n", " mu=Prior(\"Normal\"),\n", " sigma=Prior(\"HalfNormal\"),\n", " dims=mu_dims,\n", " )\n", " sigma = Prior(\n", " \"Normal\",\n", " mu=Prior(\"Normal\"),\n", " sigma=Prior(\"HalfNormal\"),\n", " centered=False,\n", " dims=sigma_dims,\n", " transform=\"exp\",\n", " )\n", " return Prior(\n", " \"Normal\",\n", " mu=mu,\n", " sigma=sigma,\n", " dims=(\"channel\", \"geo\"),\n", " )\n", "\n", "\n", "variable_2d = create_2d_variable(mu_dims=\"channel\", sigma_dims=\"geo\")\n", "variable_2d.to_graph()" ] }, { "cell_type": "markdown", "id": "e018082e-23fb-48ab-ac69-e506a8fe9d9b", "metadata": {}, "source": [ "And the user can spend more time thinking about just the assumptions of the variables rather than logic to ensure the dimensions work." ] }, { "cell_type": "code", "execution_count": 28, "id": "e0bdf8b8-34b7-4918-8106-2203b7db6152", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "clusterchannel (1) x geo (1)\n", "\n", "channel (1) x geo (1)\n", "\n", "\n", "\n", "var_sigma_raw_sigma\n", "\n", "var_sigma_raw_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_sigma_raw\n", "\n", "var_sigma_raw\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw_sigma->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_sigma\n", "\n", "var_mu_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_mu\n", "\n", "var_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_sigma->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_mu\n", "\n", "var_sigma_raw_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_mu->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_mu\n", "\n", "var_mu_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_mu->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma\n", "\n", "var_sigma\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw->var_sigma\n", "\n", "\n", "\n", "\n", "\n", "var_sigma->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_offset\n", "\n", "var_sigma_raw_offset\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_offset->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "different_assumptions_2d = create_2d_variable(mu_dims=\"channel\", sigma_dims=\"channel\")\n", "\n", "different_assumptions_2d.to_graph()" ] }, { "cell_type": "markdown", "id": "6e01638c-5e10-4796-a76b-7fd3b1b1ac3c", "metadata": {}, "source": [ "### Serialization\n", "\n", "The `to_json` and `from_json` methods can be helpful for storage of the distributions." ] }, { "cell_type": "code", "execution_count": 29, "id": "f34d2031-90f1-4c06-a0ab-2f3133cdb9c1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'dist': 'Normal',\n", " 'kwargs': {'mu': {'dist': 'Normal',\n", " 'kwargs': {'mu': {'dist': 'Normal'}, 'sigma': {'dist': 'HalfNormal'}},\n", " 'dims': ('channel',)},\n", " 'sigma': {'dist': 'Normal',\n", " 'kwargs': {'mu': {'dist': 'Normal'}, 'sigma': {'dist': 'HalfNormal'}},\n", " 'centered': False,\n", " 'dims': ('geo',),\n", " 'transform': 'exp'}},\n", " 'dims': ('channel', 'geo')}" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "variable_2d_dict = variable_2d.to_json()\n", "variable_2d_dict" ] }, { "cell_type": "code", "execution_count": 30, "id": "cd833a19-ef27-4701-8b8e-a41990bd5a10", "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "clusterchannel (1)\n", "\n", "channel (1)\n", "\n", "\n", "clustergeo (1)\n", "\n", "geo (1)\n", "\n", "\n", "clusterchannel (1) x geo (1)\n", "\n", "channel (1) x geo (1)\n", "\n", "\n", "\n", "var_sigma_raw_sigma\n", "\n", "var_sigma_raw_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_sigma_raw\n", "\n", "var_sigma_raw\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw_sigma->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_sigma\n", "\n", "var_mu_sigma\n", "~\n", "HalfNormal\n", "\n", "\n", "\n", "var_mu\n", "\n", "var_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_sigma->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_mu\n", "\n", "var_sigma_raw_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_mu->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n", "var_mu_mu\n", "\n", "var_mu_mu\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu_mu->var_mu\n", "\n", "\n", "\n", "\n", "\n", "var\n", "\n", "var\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_mu->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma\n", "\n", "var_sigma\n", "~\n", "Deterministic\n", "\n", "\n", "\n", "var_sigma_raw->var_sigma\n", "\n", "\n", "\n", "\n", "\n", "var_sigma->var\n", "\n", "\n", "\n", "\n", "\n", "var_sigma_raw_offset\n", "\n", "var_sigma_raw_offset\n", "~\n", "Normal\n", "\n", "\n", "\n", "var_sigma_raw_offset->var_sigma_raw\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Prior.from_json(variable_2d_dict).to_graph()" ] }, { "cell_type": "markdown", "id": "41abb828-e67b-4995-b20c-a83b965493c3", "metadata": {}, "source": [ "## Use in PyMC-Marketing\n", "\n", "Distributions will be expressed in this manner throughout the package including but not limited to: \n", "\n", "- MMM components\n", " - [media transformations](https://www.pymc-marketing.io/en/stable/notebooks/mmm/mmm_components.html#media-transformations)\n", " \n", "### Backwards compatibility\n", "\n", "The `from_json` method will create a `Prior` instance from the previous format.\n", "\n", "For instance, take this previous configuration: " ] }, { "cell_type": "code", "execution_count": 31, "id": "29e66da3-4fba-4f85-8379-f0d237d45123", "metadata": {}, "outputs": [], "source": [ "old_model_config = {\n", " \"alpha\": {\n", " \"dist\": \"Normal\",\n", " \"kwargs\": {\n", " \"mu\": 0,\n", " \"sigma\": 1,\n", " },\n", " },\n", " \"beta\": {\n", " \"dist\": \"Laplace\",\n", " \"kwargs\": {\n", " \"mu\": 1,\n", " \"b\": 0.5,\n", " },\n", " },\n", "}" ] }, { "cell_type": "markdown", "id": "d63987c0-2525-4b12-8415-cd62dd66265f", "metadata": {}, "source": [ "This can be parsed with the `Prior.from_json` constructor for each key. Much more consise too!" ] }, { "cell_type": "code", "execution_count": 32, "id": "92413026-9d9a-4424-b236-09f54b254545", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'alpha': Prior(\"Normal\", mu=0, sigma=1),\n", " 'beta': Prior(\"Laplace\", mu=1, b=0.5)}" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_model_config = {\n", " name: Prior.from_json(key) for name, key in old_model_config.items()\n", "}\n", "\n", "new_model_config" ] }, { "cell_type": "code", "execution_count": 33, "id": "1636ae9b-452c-4772-8b60-085c9b044154", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'dist': 'Normal', 'kwargs': {'mu': 0, 'sigma': 1}}" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_model_config[\"alpha\"].to_json()" ] }, { "cell_type": "markdown", "id": "01370c37-2e03-46bc-98c5-fcd8bae1b8e7", "metadata": {}, "source": [ "The `parse_model_config` function will do just this and is used internally. It also provides some deprecation warnings." ] }, { "cell_type": "code", "execution_count": 34, "id": "54e8e716-b2c9-4019-8620-2616f9783576", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'alpha': Prior(\"Normal\", mu=0, sigma=1),\n", " 'beta': Prior(\"Laplace\", mu=1, b=0.5)}" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_model_config(old_model_config)" ] }, { "cell_type": "markdown", "id": "9839e1c3-5026-405e-a019-09a20eaac6a1", "metadata": {}, "source": [ "As well as the ability to catch some errors while parsing." ] }, { "cell_type": "code", "execution_count": 35, "id": "00f9e291-3b8f-4457-8451-4b1fb0d0acbb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 errors occurred while parsing model configuration. Errors: Parameter alpha: PyMC doesn't have a distribution of name 'InvalidDistribution', Parameter beta: Parameters must be one of the following types: (int, float, np.array, Prior, pt.TensorVariable). Incorrect parameters: {'mu': , 'sigma': }, Parameter gamma: Parameters {'mu'} are not a subset of the pymc distribution parameters {'sigma', 'tau'}\n" ] } ], "source": [ "invalid_model_config = {\n", " \"alpha\": {\n", " \"dist\": \"InvalidDistribution\",\n", " },\n", " \"beta\": {\n", " \"dist\": \"Normal\",\n", " \"kwargs\": {\"mu\": \"one\", \"sigma\": \"two\"},\n", " },\n", " \"gamma\": {\n", " \"dist\": \"HalfNormal\",\n", " \"kwargs\": {\"mu\": 1},\n", " },\n", "}\n", "\n", "try:\n", " parse_model_config(invalid_model_config)\n", "except ModelConfigError as e:\n", " print(e)" ] }, { "cell_type": "code", "execution_count": 36, "id": "818f52e3-7d53-4b62-afd0-4331b1849509", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Last updated: Mon Jul 01 2024\n", "\n", "Python implementation: CPython\n", "Python version : 3.10.13\n", "IPython version : 8.22.2\n", "\n", "pytensor: 2.20.0\n", "\n", "arviz : 0.17.1\n", "pymc : 5.14.0\n", "numpy : 1.26.4\n", "matplotlib: 3.8.3\n", "pandas : 2.2.1\n", "\n", "Watermark: 2.4.3\n", "\n" ] } ], "source": [ "%load_ext watermark\n", "%watermark -n -u -v -iv -w -p pytensor" ] } ], "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.10.13" } }, "nbformat": 4, "nbformat_minor": 5 }