De Modelos de Mezcla de Marketing a GAMs Bayesianos Personalizados: Ampliando el Núcleo de PyMC-Marketing#

Introducción#

Mientras que PyMC-Marketing es ampliamente reconocido por sus avanzadas capacidades de Modelado de Mezcla de Marketing (MMM), su verdadero potencial se extiende mucho más allá de los marcos tradicionales de MMM. En su núcleo, PyMC-Marketing proporciona una arquitectura flexible y componible que permite la construcción de modelos probabilísticos complejos—particularmente modelos aditivos generalizados (GAMs)—dentro del paradigma bayesiano. Al aprovechar la sintaxis de modelado expresiva de PyMC y la estructura modular de PyMC-Marketing, cualquier persona puede integrar transformaciones no lineales, priors jerárquicos, dinámicas auto-regresivas con solo unas pocas líneas de código o definir sus propias transformaciones personalizadas que reflejen conocimientos específicos del dominio y perspectivas basadas en datos. Al hacerlo, PyMC-Marketing se convierte no solo en un marco para la optimización del marketing, sino también en un motor de propósito general para construir GAMs bayesianos interpretables. Esta flexibilidad lo convierte en una herramienta invaluable para cualquiera que busque combinar razonamiento causal, flexibilidad funcional e inferencia probabilística en un flujo de trabajo de modelado coherente.

Esto permite a los investigadores y analistas moverse sin problemas de los MMM estándar a modelos gráficos completamente especificados que capturan relaciones causales y funcionales más ricas entre las variables.

En el siguiente cuaderno, le mostraremos varias de estas funcionalidades. Puede leer más sobre los componentes individuales y cómo construir MMM en el cuaderno de componentes.

Importar bibliotecas#

from __future__ import annotations

import time
import warnings
from copy import deepcopy

import arviz as az
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import pymc as pm
import xarray as xr
from pymc_extras.prior import Prior

from pymc_marketing.mmm import (
    GeometricAdstock,
    LogisticSaturation,
    NoAdstock,
    NoSaturation,
)
from pymc_marketing.mmm.components.base import Transformation
from pymc_marketing.mmm.multidimensional import MMM
from pymc_marketing.special_priors import LogNormalPrior, MaskedPrior

Configuración del cuaderno#

warnings.filterwarnings("ignore", category=UserWarning)

seed: int = sum(map(ord, "pymc-marketing is more than just a marketing model"))

az.style.use("arviz-darkgrid")
plt.rcParams["figure.figsize"] = [12, 7]
plt.rcParams["figure.dpi"] = 100
plt.rcParams["xtick.labelsize"] = 10
plt.rcParams["ytick.labelsize"] = 8

%load_ext autoreload
%autoreload 2
%config InlineBackend.figure_format = "retina"

Proceso de generación de datos#

Para los siguientes ejemplos, no construiremos un gran proceso estructural, ya que el objetivo de este cuaderno es simplemente mostrar las capacidades de la biblioteca. En su lugar, generaremos algunas series temporales siguiendo caminatas aleatorias y definiremos una variable objetivo lineal simple que depende del número de controladores creados.

La serie puede verse como variables de marketing o impulsores dirigidos a un objetivo específico. A medida que avancemos por el cuaderno, generaremos numerosos ejemplos de conjuntos de datos potenciales que pueden utilizarse con cada uno de los modelos.

def random_walk(mu, sigma, steps, lower=None, upper=None, seed=None):
    """
    Generate a bounded random walk with specified mean and standard deviation.

    Parameters
    ----------
    mu : float
        Target mean of the random walk
    sigma : float
        Target standard deviation of the random walk
    steps : int
        Number of steps in the random walk
    lower : float, optional
        Lower bound for the random walk values
    upper : float, optional
        Upper bound for the random walk values
    seed : int, optional
        Random seed for reproducibility

    Returns
    -------
    np.ndarray
        Random walk array with specified mean, std, and bounds
    """
    # if seed none then set 123
    if seed is None:
        seed = 123
    # Create a random number generator with the given seed
    rng = np.random.RandomState(seed)

    # Start from the target mean
    walk = np.zeros(steps)
    walk[0] = mu

    # Generate the walk step by step with bounds checking
    for i in range(1, steps):
        # Generate a random increment using the seeded RNG
        increment = rng.normal(0, sigma * 0.1)  # Scale increment size

        # Propose next value
        next_val = walk[i - 1] + increment

        # Apply bounds if specified
        if lower is not None and next_val < lower:
            # Reflect off lower bound
            next_val = lower + (lower - next_val)
        if upper is not None and next_val > upper:
            # Reflect off upper bound
            next_val = upper - (next_val - upper)

        # Final bounds check (hard clipping as backup)
        if lower is not None:
            next_val = max(next_val, lower)
        if upper is not None:
            next_val = min(next_val, upper)

        walk[i] = next_val

    # Adjust to match target mean and std while respecting bounds
    current_mean = np.mean(walk)
    current_std = np.std(walk)

    if current_std > 0:
        # Center around zero, scale to target std, then shift to target mean
        walk_centered = (walk - current_mean) / current_std * sigma + mu

        # Apply bounds again after scaling
        if lower is not None:
            walk_centered = np.maximum(walk_centered, lower)
        if upper is not None:
            walk_centered = np.minimum(walk_centered, upper)

        walk = walk_centered

    return walk

n_days = 365
n_years = 6
n_observations = n_days * n_years
min_date = pd.to_datetime("2022-01-01")
max_date = min_date + pd.Timedelta(days=n_observations) - pd.Timedelta(days=1)
date_range = pd.date_range(start=min_date, end=max_date, freq="D")
df = pd.DataFrame(data={"date_week": date_range})

x1 = random_walk(
    mu=500, sigma=50, steps=n_observations, lower=10, upper=1000, seed=seed + 1
)
x2 = random_walk(
    mu=300, sigma=100, steps=n_observations, lower=10, upper=1000, seed=seed + 2
)
x3 = random_walk(
    mu=600, sigma=80, steps=n_observations, lower=10, upper=1000, seed=seed - 3
)
x4 = random_walk(
    mu=1000, sigma=100, steps=n_observations, lower=10, upper=3000, seed=seed - 1
)

Genial, ¡visualicemos nuestra serie temporal!

fig, axs = plt.subplots(2, 2, figsize=(10, 8))
axs[0, 0].plot(x1, color="blue")
axs[0, 0].set_title("x1")
axs[0, 1].plot(x2, color="red")
axs[0, 1].set_title("x2")
axs[1, 0].plot(x3, color="green")
axs[1, 0].set_title("x3")
axs[1, 1].plot(x4, color="orange")
axs[1, 1].set_title("x4")
plt.show()

../../_images/98b003442d63f29f162d0f1ff64a2497df57a35d2decebc78817387a24837c3d.png

Construiremos un modelo lineal simple basado en estos cuatro factores. Puede pensar en ellos como representaciones de impresiones, gasto o cualquier otra variable de marketing típica, mientras que el objetivo podría corresponder a resultados como ingresos, instalaciones, registros en el sitio o compras.

intercept = 100
noise = np.random.normal(0, 10, n_observations)
y = x1 * 0.5 + x2 * 0.3 + x3 * 0.2 + x4 * 0.1 + intercept + noise

df["x1"] = x1
df["x2"] = x2
df["x3"] = x3
df["x4"] = x4
df["y"] = y

fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(y, color="black")
ax.set_title("y")
plt.show()

../../_images/226c82f3c148404408464956d224273b910ee9f67991b5fff48c9e7b4827d3ab.png

Juntamos todos los datos en el mismo conjunto de datos.

df.head()

	date_week	x1	x2	x3	x4	y
0	2022-01-01	594.252746	156.373242	382.601781	878.408481	610.662948
1	2022-01-02	592.904201	150.323907	381.212926	878.912259	608.355639
2	2022-01-03	591.613607	151.588310	383.524140	881.134924	612.128530
3	2022-01-04	587.537071	154.705806	381.000766	889.327060	626.685458
4	2022-01-05	585.676798	158.286095	379.739704	886.491672	599.619464

Configuración del muestreador#

Crearemos un conjunto de configuraciones de muestreo predefinidas para todos nuestros modelos.

sample_kwargs = {
    "tune": 800,
    "draws": 200,
    "chains": 2,
    "random_seed": seed,
    "target_accept": 0.84,
}

Modelo Lineal Simple#

Para comenzar, construiremos un modelo lineal básico utilizando la clase MMM. Este ejemplo demuestra cómo PyMC-Marketing puede representar fácilmente una regresión lineal estándar.

Nota

PyMC-Marketing nunca obliga al uso de no linealidad. Puedes construir modelos puramente lineales cuando eso es lo que tus datos y el contexto empresarial requieren.

En esta configuración, la variable objetivo \(Y_t\) se modela como una combinación lineal de varios predictores \(X_{i,t}\), cada uno ponderado por su correspondiente coeficiente \(b_i\), más un término de error aleatorio \(\varepsilon_t\):

\[::\]

Aquí:

\(Y_t\) representa el objetivo en el tiempo \(t\) (por ejemplo, ingresos, instalaciones o registros),
\(X_{i,t}\) son las variables explicativas (por ejemplo, impresiones, gasto u otros impulsores de marketing),
\(b_i\) son los coeficientes específicos del canal que capturan la contribución marginal de cada variable, y
\(\varepsilon_t\) es el término residual que contabiliza la variación no observada.

Advertencia

Este caso representa nuestro preciso proceso de generación de datos anterior, pero lo importante es lo fácil que es escribir esta ecuación utilizando la API de MMM.

linear_model = MMM(
    date_column="date_week",
    target_column="y",
    channel_columns=["x1", "x2", "x3", "x4"],
    adstock=NoAdstock(l_max=1),
    saturation=NoSaturation().set_dims_for_all_priors("channel"),
    sampler_config=sample_kwargs,
)
linear_model.build_model(
    X=df.drop(columns=["y"]),
    y=df["y"],
)
linear_model.model.to_graphviz()

../../_images/98d0f5a88183808080e30795aba7cae60834c9e27ff8eb3b11eda80bea429710.svg

Con solo unas pocas líneas de código, puede definir un modelo lineal que ya incluye configuraciones previas flexibles y una estructura multidimensional.

La verdadera ventaja, sin embargo, no es solo construir un modelo gráfico más complejo tan fácilmente; es obtener acceso a todas las poderosas herramientas que PyMC-Marketing proporciona, incluso para una regresión simple.

PyMC-Marketing le ofrece, listo para usar:

Escalado y reescalado automáticos de entradas y salidas.
Herramientas de trazado completas para la evaluación posterior.
Análisis de sensibilidad y efecto marginal para cada nodo en el modelo.
Calibración del modelo utilizando evidencia experimental o causal.
Capacidades de asignación y optimización del presupuesto.

Todas estas características están disponibles incluso para los modelos más simples, lo que le permite pasar sin problemas de regresiones básicas a marcos de marketing probabilísticos completos.

Una vez que cada modelo esté listo, ¡puedes entrenarlos de la misma manera!

Como puede ver, ya hemos creado un modelo, añadido variables para ser transformadas en la escala original y lo hemos entrenado. Todo esto se guarda en mi objeto. ¿Cómo podríamos hacer esto un poco más complejo?

Antes de ir allí, necesitaremos agregar algo más a nuestros datos; en este caso, añadiremos algunas dimensiones adicionales para tener un conjunto de datos más grande.

countries = ["Venezuela", "Colombia", "Ecuador", "Panama"]
regions = ["South", "North", "East", "West"]
product_types = ["Type A", "Type B", "Type C", "Type D"]

multi_country_df = pd.DataFrame(
    [
        {
            "date_week": date,
            "country": country,
            "region": region,
            "product_type": product_type,
        }
        for country in countries
        for region in regions
        for product_type in product_types
        for date in date_range
    ]
)

# Create columns x1, x2, x3, x4 -> They must have for each combination of dimensions the N observations
for country_idx, country in enumerate(countries):
    for region_idx, region in enumerate(regions):
        for product_idx, product_type in enumerate(product_types):
            combination_mask = (
                (multi_country_df["country"] == country)
                & (multi_country_df["region"] == region)
                & (multi_country_df["product_type"] == product_type)
            )

            for col_idx, col in enumerate(["x1", "x2", "x3", "x4"]):
                mu = np.random.uniform(700, 800)
                sigma = np.random.uniform(50, 100)
                _seed = np.random.uniform(5, 30)
                walk_values = random_walk(
                    mu=mu,
                    sigma=sigma,
                    steps=n_observations,
                    lower=10,
                    upper=1000,
                    seed=seed
                    + country_idx * 100
                    + region_idx * 10
                    + product_idx * 1000
                    + col_idx,
                )
                multi_country_df.loc[combination_mask, col] = walk_values

multi_country_df.head()

	date_week	country	region	product_type	x1	x2	x3	x4
0	2022-01-01	Venezuela	South	Type A	765.436919	823.799535	584.513184	573.025002
1	2022-01-02	Venezuela	South	Type A	767.879888	822.156462	574.722849	572.739882
2	2022-01-03	Venezuela	South	Type A	768.306886	820.583998	576.769176	571.897202
3	2022-01-04	Venezuela	South	Type A	767.682061	815.617131	581.814580	574.540813
4	2022-01-05	Venezuela	South	Type A	768.254702	813.350567	587.608973	577.418828

Ahora nuestro conjunto de datos se ve mejor, tenemos una serie temporal con longitud de un día para cada país, región y tipo de producto. Eche un vistazo al número de series temporales hechas solo para \(x1\).

# Create subplots for each combination of country, region, and product type
fig, axes = plt.subplots(4, 4, figsize=(20, 16))
fig.suptitle("X1 Time Series by Country, Region, and Product Type", fontsize=16, y=0.98)

for _, country in enumerate(countries):
    for j, (region, product_type) in enumerate(
        [(r, p) for r in regions for p in product_types]
    ):
        if j >= 16:  # Only plot first 16 combinations to fit in 4x4 grid
            break

        row = j // 4
        col = j % 4

        # Filter data for this specific combination using query syntax
        subset = multi_country_df.query(
            f"country == '{country}' and region == '{region}' and product_type == '{product_type}'"
        )

        if len(subset) > 0:  # Only plot if data exists
            subset = subset.set_index("date_week")
            axes[row, col].plot(subset.index, subset["x1"], label=f"{country}")
            axes[row, col].set_title(f"{region} - {product_type}", fontsize=10)
            axes[row, col].tick_params(axis="x", rotation=45, labelsize=8)
            axes[row, col].tick_params(axis="y", labelsize=8)
            axes[row, col].legend(fontsize=8)

plt.tight_layout(rect=[0, 0, 1, 0.96])

../../_images/0680935add371ed3adab7d265bc0fd9f731ac5835b7fea44bdf5f17b2b9d570e.png

Para cada serie temporal, haremos una combinación lineal como antes para obtener una variable objetivo.

# Define different coefficients, intercepts, and noise levels for each combination
combination_params = {}

# Create parameters for each combination of country, region, and product type
for country in countries:
    for region in regions:
        for product_type in product_types:
            # Create unique parameters for each combination
            base_coeffs = [0.5, 0.3, 0.2, 0.1]
            base_intercept = 100
            base_noise = 10

            # Add variation based on country
            country_multiplier = {
                "Venezuela": 1.2,
                "Colombia": 1.0,
                "Ecuador": 0.9,
                "Panama": 1.1,
            }[country]

            # Add variation based on region
            region_multiplier = {"North": 1.1, "South": 0.9, "East": 1.0, "West": 0.95}[
                region
            ]

            # Add variation based on product type
            product_multiplier = {
                "Type A": 1.05,
                "Type B": 0.95,
                "Type C": 1.0,
                "Type D": 0.98,
            }[product_type]

            # Calculate final parameters
            final_multiplier = (
                country_multiplier * region_multiplier * product_multiplier
            )

            combination_params[(country, region, product_type)] = {
                "coeffs": [c * final_multiplier for c in base_coeffs],
                "intercept": base_intercept * final_multiplier,
                "noise_std": base_noise
                * (final_multiplier * 0.5 + 0.5),  # Moderate noise variation
            }

# Initialize y column
multi_country_df["y"] = 0.0

# Calculate y for each combination with different parameters
for (country, region, product_type), params in combination_params.items():
    combination_mask = (
        (multi_country_df["country"] == country)
        & (multi_country_df["region"] == region)
        & (multi_country_df["product_type"] == product_type)
    )

    if combination_mask.sum() > 0:
        # Generate combination-specific noise
        combination_noise = np.random.normal(
            0, params["noise_std"], combination_mask.sum()
        )

        # Calculate y for this combination
        combination_y = (
            multi_country_df.loc[combination_mask, "x1"] * params["coeffs"][0]
            + multi_country_df.loc[combination_mask, "x2"] * params["coeffs"][1]
            + multi_country_df.loc[combination_mask, "x3"] * params["coeffs"][2]
            + multi_country_df.loc[combination_mask, "x4"] * params["coeffs"][3]
            + params["intercept"]
            + combination_noise
        )

        multi_country_df.loc[combination_mask, "y"] = combination_y

multi_country_df.head()

	date_week	country	region	product_type	x1	x2	x3	x4	y
0	2022-01-01	Venezuela	South	Type A	765.436919	823.799535	584.513184	573.025002	1038.867295
1	2022-01-02	Venezuela	South	Type A	767.879888	822.156462	574.722849	572.739882	1034.681303
2	2022-01-03	Venezuela	South	Type A	768.306886	820.583998	576.769176	571.897202	1008.752762
3	2022-01-04	Venezuela	South	Type A	767.682061	815.617131	581.814580	574.540813	1029.568033
4	2022-01-05	Venezuela	South	Type A	768.254702	813.350567	587.608973	577.418828	1016.451906

# Create subplots for each combination of country, region, and product type
fig, axes = plt.subplots(4, 4, figsize=(20, 16))
fig.suptitle("Y Time Series by Country, Region, and Product Type", fontsize=16)

for _, country in enumerate(countries):
    for j, (region, product_type) in enumerate(
        [(r, p) for r in regions for p in product_types]
    ):
        if j >= 16:  # Only plot first 16 combinations to fit in 4x4 grid
            break

        row = j // 4
        col = j % 4

        # Filter data for this specific combination
        # Filter data for this specific combination using query syntax
        subset = multi_country_df.query(
            f"country == '{country}' and region == '{region}' and product_type == '{product_type}'"
        )

        if len(subset) > 0:  # Only plot if data exists
            subset = subset.set_index("date_week")
            axes[row, col].plot(subset.index, subset["y"], label=f"{country}")
            axes[row, col].set_title(f"{region} - {product_type}", fontsize=10)
            axes[row, col].tick_params(axis="x", rotation=45, labelsize=8)
            axes[row, col].tick_params(axis="y", labelsize=8)
            axes[row, col].legend(fontsize=8)

plt.tight_layout(rect=[0, 0, 1, 0.96])

../../_images/4d65d1754e41c8cddcf53229df46a61bfea04f9f48125eef0d531347fbf7aae3.png

Inferencia variacional para rejillas de alta dimensión#

Ya hemos visto cómo el diseño dimensional y MaskedPrior pueden reducir el espacio de parámetros al excluir combinaciones irrelevantes. Sin embargo, hay regímenes donde esto no es suficiente: a medida que añades transformaciones no lineales, tendencias/estacionalidad, estructuras de múltiples índices y efectos personalizados, puedes terminar en geometrías posteriores muy de alta dimensión. En estos casos, el MCMC exacto (por ejemplo, NUTS) puede volverse prohibitivamente costoso. Aquí es donde la inferencia aproximada brilla. Como señala acertadamente Michael Betancourt, “En altas dimensiones, las expectativas son lo único que tiene sentido.” Las aproximaciones te permiten apuntar a resúmenes informativos (por ejemplo, medias posteriores, intervalos creíbles) sin pagar el costo total del muestreo exacto.

PyMC-Marketing expone los métodos variacionales y aproximados de PyMC directamente, para que pueda cambiar de muestreo exacto a aproximación con un código mínimo. Por ejemplo, utilizando ADVI a través de pm.fit(...) y luego extrayendo muestras de la aproximación. Esta herramienta le permite prototipar y clasificar modelos grandes rápidamente. Posteriormente, puede escalar a MCMC completo si la aproximación parece adecuada y el presupuesto de cómputo lo permite. Para obtener detalles sobre los métodos de aproximación disponibles (por ejemplo, ADVI, ADVI de rango completo, SVGD), consulte la documentación de inferencia de PyMC (busque «inferencia variacional de PyMC» y pm.fit).

Advertencia

Approximations: Useful but Not Magic:

Compensación entre sesgo y varianza: Las familias variacionales pueden subestimar la varianza posterior y perder correlaciones.
Patologías en geometría: La multimodalidad, las colas pesadas y la fuerte curvatura pueden romper supuestos variacionales simples o llevar a óptimos locales deficientes.
Los diagnósticos son importantes: Monitoree las trayectorias de ELBO, verifique la estabilidad de las soluciones y compárelas con ejecuciones cortas de NUTS en modelos reducidos cuando sea posible.
Riesgo de calibración: Las decisiones posteriores (por ejemplo, la asignación de presupuesto) pueden ser excesivamente confiadas si se subestima la varianza. Considere políticas conservadoras o utilidades robustas.

_start_time = time.time()
linear_model.approximate_fit(
    X=df.drop(columns=["y"]),
    y=df["y"],
    fit_kwargs={"method": "advi"},  # goes to pm.fit(...)
    sample_kwargs={"draws": 1_000},  # goes to approximation.sample(...)
)
_end_time = time.time()
elapsed_time = _end_time - _start_time
print(f"Approximation took {elapsed_time:.2f} seconds")

Finished [100%]: Average Loss = 1,556.4

Approximation took 5.02 seconds

Reflexiones Finales#

Lo que hemos explorado aquí es solo un vistazo de lo que PyMC-Marketing puede hacer. Más allá de ser un conjunto de herramientas para el Modelado de Mezcla de Marketing, es un marco de modelado probabilístico impulsado por PyMC que te proporciona los bloques de construcción para diseñar, extender y experimentar con modelos bayesianos de cualquier complejidad, desde regresiones lineales hasta sistemas ricos, jerárquicos y conscientes del tiempo.

PyMC-Marketing no se limita para marketing y, lo más importante, no estás limitado por plantillas. Puedes construir, modificar y extender tus modelos libremente mientras te apoyas en la sólida base del motor probabilístico de PyMC. Cada capa adicional — tendencia, estacionalidad, saturación o efecto personalizado — añade expresividad sin perder claridad ni estructura.

Así que, ¡sigue explorando! Prueba nuevas transformaciones, mezcla efectos causales y funcionales, evalúa estrategias de inferencia y comparte tus ideas con la comunidad. Si hay una función que desearías que existiera, pídela o, aún mejor, ayúdanos a construirla.

PyMC-Marketing está evolucionando rápidamente, y su curiosidad es lo que impulsa su próximo paso! 🔥

%reload_ext watermark
%watermark -n -u -v -iv -w

Last updated: Tue, 17 Mar 2026

Python implementation: CPython
Python version       : 3.13.12
IPython version      : 9.11.0

arviz         : 0.23.4
matplotlib    : 3.10.8
numpy         : 2.4.2
pandas        : 2.3.3
pydantic      : 2.12.5
pymc          : 5.28.1
pymc_extras   : 0.9.3
pymc_marketing: 0.18.2
pytensor      : 2.38.2
xarray        : 2026.2.0

Watermark: 2.6.0

De Modelos de Mezcla de Marketing a GAMs Bayesianos Personalizados: Ampliando el Núcleo de PyMC-Marketing#

Introducción#

Importar bibliotecas#

Configuración del cuaderno#

Proceso de generación de datos#

Configuración del muestreador#

Modelo Lineal Simple#

Añadiendo dimensiones adicionales a nuestro modelo aditivo#

Creando un modelo multidimensional jerárquico#

Añadiendo componentes de tendencia y estacionalidad#

Funciones personalizadas en PyMC-Marketing#

Añadiendo covariables lineales#

Términos arbitrarios en PyMC-Marketing#

¿Dónde están los GAM?#

Resumen: De líneas simples a estructuras complejas#

Parámetro de Crecimiento y Tiempo de Muestreo#

Excluyendo variables del muestreo con `MaskedPrior`#

Inferencia variacional para rejillas de alta dimensión#

Reflexiones Finales#

De Modelos de Mezcla de Marketing a GAMs Bayesianos Personalizados: Ampliando el Núcleo de PyMC-Marketing#

Introducción#

Importar bibliotecas#

Configuración del cuaderno#

Proceso de generación de datos#

Configuración del muestreador#

Modelo Lineal Simple#

Añadiendo dimensiones adicionales a nuestro modelo aditivo#

Creando un modelo multidimensional jerárquico#

Añadiendo componentes de tendencia y estacionalidad#

Funciones personalizadas en PyMC-Marketing#

Añadiendo covariables lineales#

Términos arbitrarios en PyMC-Marketing#

¿Dónde están los GAM?#

Resumen: De líneas simples a estructuras complejas#

Parámetro de Crecimiento y Tiempo de Muestreo#

Excluyendo variables del muestreo con MaskedPrior#

Inferencia variacional para rejillas de alta dimensión#

Reflexiones Finales#

Excluyendo variables del muestreo con `MaskedPrior`#