MichelRojo86WPP/copilot-config / skills/meridian-mmm
meridian-mmm
VerifiedMarketing Mix Modeling con Google Meridian: instalación y requisitos, API Python real (InputData, ModelSpec, PriorDistribution, Meridian, Analyzer, BudgetOptimizer), diagnóstico de convergencia MCMC y Health Score, ROI/mROI y curvas de respuesta, optimización de presupuesto cross-channel (con y sin Reach & Frequency), y patrones de aplicación práctica. Usar al construir, depurar, interpretar o actualizar un modelo Meridian, o al compararlo con CausalImpact/MTA.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 10.2 KB |
| references/api-reference.md | markdown | 16.6 KB |
| references/conceptual-guides.md | markdown | 45.6 KB |
| references/notebooks-demos.md | markdown | 9.3 KB |
| references/wpp-context.md | markdown | 9.0 KB |
references/conceptual-guides.md
View on GitHub# Meridian — Guías Conceptuales Oficiales (Pre/Advanced/Post-modeling)
> Parte de la skill meridian-mmm. Cargar este archivo para entender conceptos: preparación de datos,
> especificación matemática, nudos/adstock/priors, national vs. geo, health checks y puntuación de salud,
> interpretación de resultados, optimización de presupuesto, planificación de escenarios, depuración y
> actualización periódica del modelo. Fuente: developers.google.com/meridian/docs/ (todas las secciones).
---
## PARTE IV — GUÍAS CONCEPTUALES OFICIALES (ANEXO)
---
### 17. Introducción y Conceptos Básicos
**Fuente:** `https://developers.google.com/meridian/docs/basics/meridian-introduction?hl=es-419`
#### 17.1 ¿Qué es Meridian?
Meridian es una librería de código abierto de Google para **Marketing Mix Modeling (MMM)** basada en **inferencia bayesiana** con muestreo MCMC (Monte Carlo basado en Cadenas de Markov). Permite:
- Cuantificar el efecto causal de cada canal de medios sobre el KPI de negocio
- Calcular ROI histórico y ROI marginal por canal
- Optimizar la asignación de presupuesto para maximizar el retorno
- Incorporar conocimiento previo (experimentos, benchmarks) a través de distribuciones a priori
#### 17.2 Diferencias con enfoques frecuentistas
| Enfoque | Frequentista (OLS) | Bayesiano (Meridian) |
|---|---|---|
| Incertidumbre | Intervalos de confianza | Intervalos creíbles (distribuciones a posteriori) |
| Conocimiento previo | No incorporable | Distribuciones a priori explícitas |
| Muestras pequeñas | Problemático | Regularización natural via priors |
| Multicolinealidad | Colapsa estimaciones | Priors evitan colapso (con precaución) |
| Tiempo de cómputo | Segundos | Minutos/horas (requiere GPU) |
#### 17.3 Glosario de términos clave
| Término | Definición |
|---|---|
| KPI | Indicador clave de rendimiento (ventas, ingresos, conversiones) |
| Resultado incremental | KPI adicional atribuible exclusivamente a los medios |
| Baseline | KPI esperado si todos los tratamientos fueran cero |
| Geo | Unidad geográfica de análisis (país, región, DMA…) |
| Periodo | Unidad temporal (semana, día, mes) |
| Prior | Distribución de probabilidad sobre un parámetro antes de ver los datos |
| Posterior | Distribución actualizada tras ver los datos |
| R-hat | Estadístico de convergencia de MCMC (debe ser < 1.1 ideal, < 1.2 mínimo) |
| PPP | Predictive Posterior P-value (bondad de ajuste bayesiana) |
---
### 18. Pre-modelado
**Fuentes:** `https://developers.google.com/meridian/docs/pre-modeling/`
#### 18.1 Recolección de datos
**Fuente:** `https://developers.google.com/meridian/docs/pre-modeling/collect-data?hl=es-419`
**Datos necesarios:**
| Tipo | Descripción | Formato sugerido |
|---|---|---|
| KPI | Variable objetivo (ventas, ingresos, leads) | Semanal por geografía |
| Inversión en medios | Gasto por canal, geo y periodo | € o $ |
| Métricas de medios | Impresiones, GRPs, clics, alcance | Según canal |
| Variables de control | Factores externos (temporada, competencia, precios) | Misma granularidad |
| Población | Número de habitantes por geografía | Constante o anual |
**Granularidad temporal recomendada:** Semanal es el estándar. Diario es posible pero aumenta drásticamente el número de parámetros. Mensual pierde resolución para Adstock.
#### 18.2 Cantidad de datos necesaria
**Fuente:** `https://developers.google.com/meridian/docs/pre-modeling/amount-data-needed?hl=es-419`
| Escenario | Datos mínimos por parámetro | Regla práctica |
|---|---|---|
| Nacional (sin pooling) | ~15 datos/parámetro | Con 50 periodos: máximo ~3 canales |
| Geo "estricto" (sin pooling) | ≥8 datos/parámetro | Conservador |
| Geo "flexible" (pooling total) | ≥74 datos/parámetro | Teórico |
| Geo (guía práctica EDA) | Usa cálculo flexible como referencia | El modelo hace pooling parcial |
**Cómo calcular datos disponibles vs. parámetros:**
```
# Para modelo geográfico:
datos_efectivos = n_geos × n_times
parámetros_por_canal = ~4 (alpha, ec, slope + beta)
parámetros_globales = n_knots + n_controls × 2 + n_geos
# Regla simplificada:
ratio = datos_efectivos / parámetros_totales
# Debe ser >> 8 (estricto) o >> 74 (flexible)
```
#### 18.3 Selección de geos para modelo nacional vs. geográfico
**Fuente:** `https://developers.google.com/meridian/docs/pre-modeling/geo-selection-national-data?hl=es-419`
| Modelo | Cuándo usar | Limitaciones |
|---|---|---|
| **Nacional** (1 geo) | Datos no disponibles por geo; presupuesto único nacional | Menos identificable (más dependiente de priors) |
| **Geográfico** (multi-geo) | Datos por región/DMA disponibles; variación geográfica en medios | Requiere más datos; mayor complejidad |
**Ventaja del modelo geográfico:** La variación en la ejecución de medios *entre geos* en el mismo periodo temporal actúa como un experimento natural, mejorando la identificabilidad del efecto causal.
#### 18.4 Análisis Exploratorio de Datos (EDA)
**Fuente:** `https://developers.google.com/meridian/docs/pre-modeling/perform-eda?hl=es-419`
Meridian ejecuta automáticamente checks de EDA al inicializar el objeto `Meridian` (o al llamar a `sample_posterior`):
| Check | Umbral de error | Umbral de advertencia |
|---|---|---|
| Correlación pairwise | ERROR si `|corr| > 0.999` | — |
| VIF (multicolinealidad) | ERROR si `VIF > 1,000` | — |
| Std del KPI | ERROR si `std < 1e-4` (KPI constante) | — |
| Variación temporal/geo | ERROR si variable completamente constante | — |
```python
# EDA manual antes del modelado
from meridian.data import eda
eda_report = eda.EDAReport(input_data)
eda_report.check_correlations() # correlaciones pairwise
eda_report.check_vif() # Factor de Inflación de la Varianza
eda_report.check_kpi_variance() # varianza del KPI
eda_report.plot_media_vs_kpi() # scatterplots media vs KPI
```
#### 18.5 Plataforma MMM de Google
**Fuente:** `https://developers.google.com/meridian/docs/pre-modeling/using-mmm-data-platform?hl=es-419`
Google ofrece una plataforma de preparación de datos para Meridian que estandariza el formato de entrada. El esquema incluye:
- Tablas de hechos de medios con dimensiones: `date`, `geo`, `channel`, `impressions`, `spend`
- Tablas de KPI con dimensiones: `date`, `geo`, `kpi_value`
- Tablas de controles con dimensiones: `date`, `geo`, `control_name`, `control_value`
---
### 19. Especificación Matemática del Modelo
**Fuente:** `https://developers.google.com/meridian/docs/advanced-modeling/model-spec?hl=es-419`
#### 19.1 Ecuación completa del modelo
$$y_{g,t} = \underbrace{\mu_t + \tau_g}_{\text{baseline}} + \underbrace{\sum_{i=1}^{N_C} \gamma_{g,i}^{[C]} z_{g,t,i}}_{\text{controles}} + \underbrace{\sum_{i=1}^{N_M} \beta_{g,i}^{[M]} \text{HillAdstock}(x_{g,t,i}^{[M]})}_{\text{medios pagados}} + \underbrace{\sum_{i=1}^{N_{OM}} \beta_{g,i}^{[OM]} \text{HillAdstock}(x_{g,t,i}^{[OM]})}_{\text{medios orgánicos}} + \underbrace{\sum_{i=1}^{N_{RF}} \beta_{g,i}^{[RF]} \text{Adstock}(r_{g,t,i} \cdot \text{Hill}(f_{g,t,i}))}_{\text{canales R\&F}} + \underbrace{\sum_{i=1}^{N_N} \gamma_{g,i}^{[N]} n_{g,t,i}}_{\text{tratamientos no-media}} + \varepsilon_{g,t}$$
Donde:
- $g$ = geografía, $t$ = periodo de tiempo
- $\mu_t$ = efecto temporal (tendencia/estacionalidad) mediante nudos
- $\tau_g$ = efecto geográfico diferencial
- $\gamma_{g,i}^{[C]}$ = coeficiente geográfico del control $i$ (modelo jerárquico)
- $\beta_{g,i}^{[M]}$ = coeficiente geográfico del canal de medios $i$ (modelo jerárquico)
- $\varepsilon_{g,t} \sim N(0, \sigma_g)$
#### 19.2 Función HillAdstock
El orden por defecto es `hill_before_adstock=False`, lo que significa:
$$\text{HillAdstock}(x; \alpha, ec, \text{slope}) = \text{Hill}(\text{Adstock}(x; \alpha); ec, \text{slope})$$
**Adstock primero → Hill después** (recomendado en la mayoría de casos)
#### 19.3 Función Hill (Saturación)
$$\text{Hill}(x; ec, \text{slope}) = \frac{1}{1 + (x/ec)^{-\text{slope}}}$$
- `ec` = punto de media-saturación (cuando `x = ec`, el efecto es 0.5)
- `slope < 1` → curva cóncava (retornos decrecientes inmediatos)
- `slope > 1` → curva en S (efecto umbral antes de saturación)
- `slope = 1` → función sigmoide estándar
#### 19.4 Función Adstock (Decaimiento)
Normalización: el efecto es la media ponderada sobre `max_lag` retardos:
$$\text{Adstock}(x_{g,t}; \alpha) = \frac{\sum_{s=0}^{L} w(s; \alpha) \cdot x_{g,t-s}}{\sum_{s=0}^{L} w(s; \alpha)}$$
**Decaimiento geométrico** (`adstock_decay_spec='geometric'`):
$$w(s; \alpha) = \alpha^s$$
- `α = 0` → sin efecto de lag (solo impacto inmediato)
- `α = 1` → todos los lags tienen el mismo peso
- Rango `max_lag` recomendado: 2–10 semanas
**Decaimiento binomial** (`adstock_decay_spec='binomial'`):
- Pesos inspirados en la distribución binomial
- Permite capturar efectos que **aumentan** antes de decaer (hump-shaped)
- Rango `max_lag` recomendado: 4–20 semanas
#### 19.5 Nudos temporales (Baseline `μ_t`)
$$\mu_t = W_t \cdot b$$
Donde $b$ es un vector de K valores de nudos (K ≤ T parámetros) y $W_t$ es la matriz de pesos determinista calculada por interpolación lineal basada en distancia L1 a los dos nudos adyacentes.
- **Default geo:** `knots = n_times` (un nudo por periodo, máxima flexibilidad)
- **Default nacional:** `knots = 1` (un solo intercepto, necesario para identificabilidad)
---
### 20. Variables de Control y Tratamiento
**Fuentes:** `https://developers.google.com/meridian/docs/advanced-modeling/control-variables?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/organic-and-non-media-variables?hl=es-419`
#### 20.1 Tabla comparativa de tipos de variables
| Tipo | Coste monetario | Adstock/Hill | Intervenible | ROI | Contribución |
|---|---|---|---|---|---|
| `media` (medios pagados) | ✅ | ✅ | ✅ | ✅ | ✅ |
| `organic_media` | ❌ | ✅ | ✅ | ❌ | ✅ |
| `non_media_treatments` | ❌ | ❌ | ✅ | ❌ | ✅ |
| `controls` | ❌ | ❌ | ❌ | ❌ | ❌ |
#### 20.2 Criterios para seleccionar variables de control
Una variable debe ser incluida como **control** si cumple:
1. **Afecta causalmente al KPI** (es causa del KPI, no consecuencia)
2. **Es exógena** (no es causada por los medios)
3. **Varía en el tiempo o entre geos** (si es constante, es colineal con el intercepto)
Ejemplos de controles típicos:
- Temperatura, precipitación (retail, turismo)
- Festividades, eventos especiales
- Índices económicos (IPC, desempleo)
- Actividad de la competencia (si disponible)
- Precio propio del producto
#### 20.3 Variables de control con retardo (Lagged Controls)
Las variables de control **no** se procesan con Adstock/Hill, pero pueden incluirse con retardos manuales:
```python
import numpy as np
# Crear versión retardada del control (ej: precio con lag de 2 semanas)
controls_lagged = np.roll(controls_array, shift=2, axis=1)
controls_lagged[:, :2] = 0 # rellenar los primeros periodos con 0
# Incluir en InputData junto con el control original
controls_combined = np.concatenate([controls_array, controls_lagged], axis=-1)
```
#### 20.4 Escala poblacional de controles
Por defecto, los controles **NO** se escalan por población. Para controles a nivel nacional (que no varían entre geos como el índice de precios), es importante habilitarlo:
```python
model_spec = spec.ModelSpec(
control_population_scaling_id=[True, False, True], # escala controles 0 y 2
# ...
)
```
#### 20.5 GQV (Google Query Volume) como variable de confusión
**Fuente:** `https://developers.google.com/meridian/docs/advanced-modeling/paid-search-modeling?hl=es-419`
Para canales de búsqueda pagada (SEM):
```
Confounders: [GQV_branded, GQV_generic]
↓ ↓
SEM_branded → KPI ← SEM_generic
```
El GQV es un **confounding variable** (causa tanto las búsquedas de pago como el KPI directamente). **No incluirlo produce sobreestimación del ROI de SEM**.
Recomendaciones:
- Incluir GQV como **control** (no como media)
- Escalar GQV por población
- Usar GQV_branded y GQV_generic por separado si se modelan búsquedas branded/generic
```python
# GQV en controles, con scaling de población
controls = np.stack([gqv_branded, gqv_generic, other_controls], axis=-1)
control_population_scaling_id = [True, True, False] # escala GQV por población
```
---
### 21. Parámetros Temporales — Nudos (Knots)
**Fuentes:** `https://developers.google.com/meridian/docs/advanced-modeling/setting-knots?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/set-max-lag-parameter?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/set-adstock-decay-spec-parameter?hl=es-419`
#### 21.1 Configuraciones de nudos
```python
from meridian.model import spec
# 1. Número fijo de nudos (distribuidos uniformemente)
model_spec = spec.ModelSpec(knots=26) # un nudo cada ~2 semanas en datos de 52 semanas
# 2. Posiciones específicas
model_spec = spec.ModelSpec(knots=[0, 13, 26, 39, 52]) # trimestral
# 3. AKS (Automatic Knot Selection) - recomendado
model_spec = spec.ModelSpec(enable_aks=True)
# 4. Hybrid: AKS con nudos obligatorios (útil para refresh del modelo)
from meridian.model import knots as knots_module
aks_result = knots_module.AKS(input_data).automatic_knot_selection(
required_knots=[0, 52], # nudos obligatorios (inicio y punto fijo)
excluded_knots=[30, 31], # nudos excluidos explícitamente
restrict_to_right_of_required_knots=True # el AKS solo selecciona a la derecha del último required
)
model_spec = spec.ModelSpec(knots=aks_result)
```
#### 21.2 Cuándo usar `knots < n_times`
**El caso más importante:** Si una variable de control varía *solo* en el tiempo (sin variación geográfica — es decir, es una variable "nacional") Y `knots = n_times`, el modelo tiene **multicolinealidad perfecta** entre esa variable y los nudos. En ese caso:
- **Opción A:** Reducir `knots < n_times` (ej: `knots=52` para datos de 2 años semanales)
- **Opción B:** Eliminar la variable de control nacional (si los nudos capturan bien la tendencia)
#### 21.3 AKS (Automatic Knot Selection)
El algoritmo AKS minimiza el **AIC** (Criterio de Información de Akaike) con una penalización ajustada por el número de geos:
```
Penalización AKS = 2 × K / n_geos (en lugar del 2K estándar de AIC)
```
Esto compensa el hecho de que, con muchas geos, el modelo tiene muchos datos y podría sobre-seleccionar nudos.
**Selección Híbrida para refresh del modelo:** Al actualizar el modelo con datos nuevos, usar `restrict_to_right_of_required_knots=True` con el último nudo del modelo anterior como `required_knots` garantiza que los nuevos nudos no cambien la posición de los anteriores (consistencia temporal).
#### 21.4 Configuración de `max_lag`
**Fuente:** `https://developers.google.com/meridian/docs/advanced-modeling/set-max-lag-parameter?hl=es-419`
| Decaimiento | `max_lag` recomendado | Notas |
|---|---|---|
| Geométrico | 2–10 periodos | Para efectos que decaen rápidamente |
| Binomial | 4–20 periodos | Para efectos que tardan más en alcanzar el pico |
El valor de `max_lag` también afecta la **ventana previa de medios** necesaria: si `max_lag=8` y el KPI comienza en semana 0, los datos de medios deben empezar en semana -8.
#### 21.5 Geometric vs. Binomial Adstock
**Fuente:** `https://developers.google.com/meridian/docs/advanced-modeling/set-adstock-decay-spec-parameter?hl=es-419`
| Propiedad | Geométrico | Binomial |
|---|---|---|
| Forma del decaimiento | Monotónico decreciente desde t=0 | Puede aumentar antes de decrecer |
| Prior de `alpha` | `Uniform(0,1)` | `Uniform(0,1)` |
| `max_lag` recomendado | 2–10 | 4–20 |
| Uso típico | Medios digitales, display | TV, radio (donde el efecto tarda en activarse) |
| Interpretación de `alpha` | Alta `α` = larga vida del efecto | Igual |
---
### 22. Distribuciones a Priori
**Fuentes:** `https://developers.google.com/meridian/docs/advanced-modeling/intro-priors?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/how-to-choose-treatment-prior-types?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/roi-mroi-contribution-parameterizations?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/default-prior-distributions?hl=es-419`
#### 22.1 Tipos de prior para canales de medios pagados
| Tipo | Parámetro en `PriorDistribution` | Especificado en `ModelSpec` via | Cuándo usar |
|---|---|---|---|
| **ROI** | `roi_m`, `roi_rf` | `media_prior_type='roi'` (default) | Tienes datos de experimentos de incrementalidad; es la opción más intuitiva |
| **mROI** | `mroi_m`, `mroi_rf` | `media_prior_type='mroi'` | Quieres regularizar cambios de presupuesto recomendados; los canales están cerca de saturación |
| **Contribución** | `contribution_m`, `contribution_rf` | `media_prior_type='contribution'` | No tienes datos de ingresos; el KPI no es monetario |
| **Coeficiente** | `beta_m`, `beta_rf` | `media_prior_type='coefficient'` | Objetivos estadísticos específicos; no recomendado en general |
#### 22.2 Tipos de prior para medios orgánicos y no-media
| Tipo de variable | Prior por defecto | Tipos disponibles |
|---|---|---|
| Medios orgánicos | Contribución | `'contribution'`, `'coefficient'` |
| Tratamientos no-media | Contribución | `'contribution'`, `'coefficient'` |
#### 22.3 Diagramas de decisión (flowchart)
**Para medios pagados, la lógica es:**
1. ¿Tienes datos de ingresos o `revenue_per_kpi`?
- SÍ → Usar `roi_m` o `mroi_m`
- NO → Usar `contribution_m` o `coefficient`
2. ¿Tienes experimentos de incrementalidad?
- SÍ → Usar `roi_m` con la media calibrada en el resultado del experimento
3. ¿Quieres regularizar la optimización de presupuesto (cambios conservadores)?
- SÍ → Usar `mroi_m` con media cercana a 1.0 y std pequeño
#### 22.4 Reparametrización matemática (ROI ↔ Beta)
La reparametrización del ROI convierte el modelo estándar en términos de `beta_m` (coeficiente de regresión) a términos de `roi_m` (métrica de negocio):
$$\text{ROI}_m \times \text{Cost}_m = \sum_{g,t} \beta_{g,m} \cdot M_{g,t,m}$$
donde:
$$M_{g,t,m} = u_{g,t}^{[Y]} p_g s \cdot \text{HillAdstock}(x_{g,t,m})$$
El parámetro `beta_m` se determina como función de `ROI_m` y los demás parámetros del modelo. La ventaja es que se puede especificar una distribución a priori directamente en la métrica de negocio conocida.
#### 22.5 Ejemplos completos de código para priors
```python
import tensorflow_probability as tfp
from meridian.model import spec, prior_distribution
# ====== EJEMPLO 1: Prior ROI con calibración de experimento ======
# Experimento sugiere ROI medio = 1.7 para canal 0, 2.5 para canal 1
prior = prior_distribution.PriorDistribution(
roi_m=prior_distribution.PriorDistribution.lognormal_dist_from_mean_std(
mean=[1.7, 2.5],
std=[0.3, 0.5] # std pequeño = prior más informativo
)
)
model_spec = spec.ModelSpec(prior=prior, media_prior_type='roi')
# ====== EJEMPLO 2: Prior mROI para regularizar presupuesto ======
# Asume que ambos canales están cerca de saturación (mROI ≈ 1.0)
prior = prior_distribution.PriorDistribution(
mroi_m=prior_distribution.PriorDistribution.lognormal_dist_from_mean_std(
mean=[1.0, 1.0],
std=[0.2, 0.2] # std pequeño = cambios pequeños en presupuesto
)
)
model_spec = spec.ModelSpec(prior=prior, media_prior_type='mroi')
# ====== EJEMPLO 3: Prior Contribución para KPI no monetario ======
# Canal 0 esperamos ~3% de contribución, canal 1 ~4%
prior = prior_distribution.PriorDistribution(
contribution_m=tfp.distributions.Beta(
concentration1=[3.0, 4.0],
concentration0=[97.0, 96.0] # Beta(3,97) tiene media=3%
)
)
model_spec = spec.ModelSpec(prior=prior, media_prior_type='contribution')
# ====== EJEMPLO 4: Prior para canales orgánicos ======
prior = prior_distribution.PriorDistribution(
contribution_om=tfp.distributions.Beta(
concentration1=[3.0, 3.0],
concentration0=[97.0, 97.0]
)
)
model_spec = spec.ModelSpec(prior=prior, organic_media_prior_type='contribution')
# ====== EJEMPLO 5: Prior Adstock más informativo ======
prior = prior_distribution.PriorDistribution(
alpha_m=tfp.distributions.Beta(2.0, 5.0) # concentrado en valores bajos (~0.3)
)
```
---
### 23. Datos de Entrada y Transformaciones
**Fuentes:** `https://developers.google.com/meridian/docs/advanced-modeling/input-data?hl=es-419`, `https://developers.google.com/meridian/docs/advanced-modeling/holdout-observations?hl=es-419`
#### 23.1 Ventana previa de medios (Pre-modeling window)
Para modelar correctamente el efecto de Adstock en los primeros periodos del KPI, los datos de medios pueden incluir periodos **anteriores** al primer periodo del KPI:
```python
# Si KPI empieza en semana 0 y max_lag=8:
# media_time_coords puede incluir semanas [-8, -7, ..., -1, 0, 1, ..., T]
# time_coords del KPI: [0, 1, ..., T]
input_data = InputData.build(
kpi=kpi_array, # shape: [G, T]
media=media_array, # shape: [G, T+8, M] — 8 semanas extra al inicio
media_time_coords=list(range(-8, T)), # incluye ventana previa
time_coords=list(range(0, T)), # solo periodos del KPI
# ...
)
```
#### 23.2 Observaciones holdout
Las observaciones holdout se excluyen de la **verosimilitud** durante el ajuste, pero los medios siguen siendo utilizados (afectan el Adstock de periodos futuros):
```python
import numpy as np
# Crear máscara holdout: últimas 4 semanas para todas las geos
holdout_id = np.zeros((n_geos, n_times), dtype=bool)
holdout_id[:, -4:] = True # excluir últimas 4 semanas
model_spec = spec.ModelSpec(
holdout_id=holdout_id,
# ...
)
```
> ⚠️ **Advertencia:** No excluir bloques contiguos grandes al final del periodo. Los nudos necesitan datos cercanos para funcionar correctamente. Se recomienda usar holdout en periodos intercalados o en una proporción pequeña (<10%) de los datos.
---
### 24. Modelos Nacionales vs. Geográficos
**Fuente:** `https://developers.google.com/meridian/docs/advanced-modeling/national-models?hl=es-419`
#### 24.1 Diferencias automáticas en modelos nacionales
Cuando `n_geos = 1`, Meridian ajusta automáticamente:
| Parámetro | Modelo Geográfico | Modelo Nacional |
|---|---|---|
| `eta_m`, `eta_rf` | Estimado (varianza geo de medios) | Forzado a 0 |
| `xi_c`, `xi_n` | Estimado (varianza geo de controles) | Forzado a 0 |
| `tau_g` | Estimado para cada geo | Forzado a 0 (solo 1 geo) |
| `unique_sigma_for_each_geo` | Puede ser True | Forzado a False |
| `knots` default | `n_times` | `1` |
#### 24.2 Implicaciones para la identificabilidad
En el modelo nacional, con `knots=1` (un solo intercepto), el modelo es menos flexible pero más identificable. La recomendación es:
- Si hay **tendencia** o **estacionalidad** en el KPI → aumentar `knots` (ej: `knots=4` o `knots=12`)
- Si las variables de control capturan bien la tendencia → mantener `knots` bajo
- Nunca usar `knots = n_times` con variables de control a nivel nacional (multicolinealidad perfecta)
---
### 25. Post-modelado: Health Checks y Puntuación de Salud
**Fuentes:** `https://developers.google.com/meridian/docs/post-modeling/health-checks?hl=es-419`, `https://developers.google.com/meridian/docs/post-modeling/health-score?hl=es-419`
#### 25.1 Ejecutar health checks
```python
from meridian.analysis import visualizer
model_diagnostics = visualizer.ModelDiagnostics(mmm)
health_report = model_diagnostics.run_health_checks()
print(health_report)
```
#### 25.2 Los 6 componentes del Health Score (0–100)
| Componente | Peso | Condición PASS | Acción si FAIL/REVIEW |
|---|---|---|---|
| **Convergencia R-hat** | Gate (bloqueo) | R-hat < 1.2 para todos los parámetros; si FAIL → Score = 0 | Más cadenas, más iteraciones |
| **PPP (Bayesian p-value)** | 30% | PPP ≥ 0.05 | Revisar especificación del modelo, priors, controles |
| **Probabilidad de baseline negativo** | 30% | P(baseline < 0) < 0.2 | Ajustar priors de ROI/contribución; aumentar controles |
| **R² (Bondad de ajuste)** | 10% | R² > 0 (transformación sigmoidal) | Revisar si conflicto prior-datos es intencional |
| **Shift prior→posterior ROI** | 15% | Cambio estadísticamente significativo en ≥1 estadístico | Canal con poca señal; considerar combinar canales |
| **Consistencia del ROI** | 15% | Media posterior ROI entre P1 y P99 del prior | ROI extremo; revisar datos o priors |
#### 25.3 Fórmula del Health Score
```
Score_final =
IF convergence_FAIL: 0
ELSE:
0.30 × score_ppp +
0.30 × score_baseline +
0.10 × score_r2 +
0.15 × score_roi_shift +
0.15 × score_roi_consistency
```
**Interpretación:**
- Score ≥ 90 → Modelo bueno
- 70 < Score < 90 → Modelo aceptable, revisar componentes en REVIEW
- Score ≤ 70 → Modelo requiere investigación importante
#### 25.4 Detalles del check de convergencia
```python
# R-hat por parámetro
convergence = model_diagnostics.check_convergence()
max_rhat = convergence.max_r_hat
# Objetivo: max_r_hat < 1.1 (ideal) o < 1.2 (mínimo aceptable)
# Visualizar trazas de cadenas MCMC
model_diagnostics.plot_trace(parameter='roi_m')
```
#### 25.5 Detalles del PPP (Posterior Predictive P-value)
El PPP verifica si los datos observados son "típicos" bajo el modelo ajustado:
```
PPP = P(T(y_rep) ≥ T(y_obs) | data)
donde T es una estadística de prueba (ej: varianza total, χ²)
```
- `PPP ≈ 0.5` → El modelo es perfectamente calibrado
- `PPP < 0.05` → El modelo sistémicamente subestima la varianza (FAIL)
- `PPP > 0.95` → El modelo sobreestima la varianza
#### 25.6 Check de shift prior→posterior ROI
Meridian realiza **prueba de hipótesis bilateral** (bootstrap) comparando estadísticos (media, mediana, Q1, Q3) entre prior y posterior por canal. Si ningún estadístico cambia significativamente (p-value > 0.05), el canal tiene status REVIEW:
```python
# Visualizar prior vs posterior por canal
model_diagnostics.plot_prior_and_posterior_distribution()
```
---
### 26. Post-modelado: Resultados — Ajuste, ROI y Baseline
**Fuentes:** `https://developers.google.com/meridian/docs/post-modeling/model-fit?hl=es-419`, `https://developers.google.com/meridian/docs/post-modeling/roi-mroi-response-curves?hl=es-419`, `https://developers.google.com/meridian/docs/post-modeling/baseline?hl=es-419`
#### 26.1 Métricas de ajuste
```python
from meridian.analysis import analyzer, summarizer
a = analyzer.Analyzer(mmm)
# R² (proporción de varianza explicada)
r2 = a.r_squared() # escalar o por geo
# MAPE y wMAPE
summary = summarizer.MeridianSummarizer(mmm)
fit_metrics = summary.model_fit_metrics()
# Retorna DataFrame con: r_squared, mape, wmape
```
#### 26.2 Evaluación del baseline
El **baseline** es el resultado esperado si todos los tratamientos (medios, orgánicos, no-media) se establecen a sus valores de referencia (0 para medios, mínimo para no-media):
```python
# Probabilidad de baseline negativo (debe ser < 0.2)
prob_neg = a.negative_baseline_probability()
print(f"P(baseline < 0) = {prob_neg:.3f}")
# Si prob_neg > 0.2 → modelo tiene problema de atribución excesiva
```
**Causas comunes de baseline negativo:**
1. Priors de ROI/contribución demasiado permisivos (los medios reciben demasiado crédito)
2. Insuficientes controles (variables de confusión no capturadas)
3. Insuficientes nudos (tendencia temporal no capturada)
**Mitigación:**
```python
# Calcular probabilidad a priori de contribución total > 100%
mmm.sample_prior(n_samples=1000)
a_prior = analyzer.Analyzer(mmm)
prior_contribution = a_prior.incremental_outcome(use_posterior=False) / total_outcome
prob_over_100 = np.mean(np.sum(prior_contribution, axis=-1) > 1)
# Si prob_over_100 > 0.2 → ajustar priors antes de ajustar el modelo
```
#### 26.3 Definición del resultado incremental
$$\text{IncrementalOutcome}_m = \text{E}[Y | x_m = x_m^{hist}] - \text{E}[Y | x_m = 0]$$
- Compara resultado esperado con medios históricos vs. resultado esperado sin ese canal de medios
- Para medios pagados: `ROI = IncrementalOutcome / Spend`
- Para medios orgánicos: `Contribution = IncrementalOutcome / TotalOutcome`
---
### 27. Post-modelado: Visualizaciones e Interpretación
**Fuente:** `https://developers.google.com/meridian/docs/post-modeling/interpret-visualizations?hl=es-419`
#### 27.1 Informe HTML automático
```python
from meridian.analysis import summarizer
s = summarizer.MeridianSummarizer(mmm)
# Generar informe HTML de 2 páginas (modelo + optimización)
s.generate_model_results_output(
period_start='2024-01-01',
period_end='2024-12-31',
output_path='meridian_report.html'
)
```
#### 27.2 Gráficos disponibles y su interpretación
| Gráfico | Tipo | Interpretación |
|---|---|---|
| **Model fit (Expected vs. Actual)** | Serie temporal | Línea azul (esperada) vs. verde (real); línea dorada = sin medios |
| **Channel contribution waterfall** | Cascada | Contribución incremental de cada canal al resultado total |
| **Pie chart de contribuciones** | Circular | % del KPI atribuible a medios vs. baseline |
| **ROI by channel** | Barras con IC creíble | Comparación de ROI medio e IC 90% por canal |
| **mROI vs. ROI** | Scatter | Canales en cuadrante mROI>1, ROI>media = excelentes candidatos a reinversión |
| **Effectiveness vs. ROI** | Scatter | Efectividad = ingresos/impresión (no depende del presupuesto) |
| **Response curves** | Curvas | Gasto (eje X) vs. resultado incremental (eje Y); punto actual = círculo |
| **Adstock decay curves** | Curvas | Peso por lag (0 a max_lag); prior vs. posterior |
| **Hill saturation curves** | Curvas + histograma | Efecto relativo vs. unidades de medios per cápita; histograma de ejecución histórica |
#### 27.3 Gotchas de interpretación
- Las **curvas de respuesta fuera del rango histórico** son extrapolaciones paramétricas — usar con cautela para decisiones de inversión
- **ROI alto + mROI bajo** = canal saturado (posible sobreinversión)
- **ROI bajo + mROI alto** = canal con potencial (posible subinversión)
- Las **curvas de Hill** con histograma concentrado en un rango estrecho indican que el modelo no ha observado variación suficiente fuera de ese rango
---
### 28. Post-modelado: Optimización de Presupuesto
**Fuentes:** `https://developers.google.com/meridian/docs/post-modeling/interpret-optimizations?hl=es-419`, `https://developers.google.com/meridian/docs/post-modeling/optimization-without-reach-frequency?hl=es-419`, `https://developers.google.com/meridian/docs/post-modeling/optimization-with-reach-frequency?hl=es-419`
#### 28.1 Función objetivo de la optimización
Para **presupuesto fijo** (sin R&F):
$$b_{\text{optimal}} = \underset{b \in B_C}{\text{argmax}} \frac{1}{J} \sum_{j=1}^J \sum_{g,t} u_{g,t}^{[Y]} L_{g,t}^{[Y]-1} \left( \sum_{m} \beta_{g,m}^{(j)} \text{HillAdstock}\left(\frac{x_{g,t,m}^{hist} \cdot b_m}{c_m}\right) \right)$$
Donde:
- $c_m$ = gasto histórico del canal $m$ en el periodo de optimización
- $b_m$ = nuevo presupuesto propuesto para canal $m$
- $b_m/c_m$ = ratio de ajuste que escala las unidades de medios proporcionalmente
**Supuestos clave del optimizador:**
- El patrón de distribución temporal/geográfico del canal permanece constante
- El costo por unidad de medios no depende del presupuesto (no hay descuentos por volumen)
#### 28.2 Modos de optimización
```python
from meridian.analysis import optimizer
opt = optimizer.BudgetOptimizer(mmm)
# 1. Presupuesto fijo: redistribuir €1M entre canales
result_fixed = opt.optimize(budget=1_000_000)
# 2. Presupuesto flexible + ROI objetivo: maximizar ingresos con ROI ≥ 1.5
result_roi = opt.optimize(roi_target=1.5)
# 3. Presupuesto flexible + mROI mínimo: invertir hasta mROI = 1.0 por canal
result_mroi = opt.optimize(mroi_min=1.0)
# Con restricciones por canal
result_constrained = opt.optimize(
budget=1_000_000,
pct_of_spend={
'tv': (0.5, 1.5), # TV: entre 50% y 150% del histórico
'search': (0.8, 2.0) # Search: entre 80% y 200% del histórico
}
)
```
#### 28.3 Optimización con R&F: Frecuencia óptima
La **frecuencia óptima** se calcula primero (es independiente del presupuesto):
$$f_{\text{optimal}, i} = \underset{f_i}{\text{argmax}} \sum_{j,g,t} \beta_{g,i}^{[RF](j)} \text{Adstock}\left(\frac{r_{g,t,i}^{hist} f_{g,t,i}^{hist}}{f_i} \text{Hill}(f_i; ec_i^{RF}, \text{slope}_i^{RF})\right)$$
Luego el optimizador usa esa frecuencia óptima al asignar el presupuesto:
```python
# Optimizar con frecuencia óptima (recomendado si tienes R&F)
result_rf = opt.optimize(
budget=1_000_000,
use_optimal_frequency=True
)
# vs. frecuencia histórica (más conservador)
result_rf_hist = opt.optimize(
budget=1_000_000,
use_optimal_frequency=False
)
```
---
### 29. Post-modelado: Planificación de Escenarios Futuros
**Fuente:** `https://developers.google.com/meridian/docs/post-modeling/scenario-planning-and-future-budget-optimization?hl=es-419`
#### 29.1 Concepto clave
La planificación de escenarios modifica las **definiciones de las métricas** (ROI, resultado incremental) pero **no** re-estima los parámetros del modelo. Se puede cambiar:
- Costo por unidad de medios (ej: si el CPC aumentó)
- Ingresos por KPI (ej: si el precio del producto cambió)
- Patrón de distribución (ej: nuevo canal con diferente distribución histórica)
#### 29.2 Argumento `new_data`
La mayoría de métodos de `Analyzer` y `BudgetOptimizer` aceptan `new_data` para definir el escenario:
```python
from meridian.data import test_data
# Escenario: el CPC de búsqueda aumentó un 20%
new_spend = original_spend.copy()
new_spend[:, :, search_channel_idx] *= 1.20 # 20% más caro
new_data = test_data.InputData.build(
media_spend=new_spend,
media=original_impressions, # las impresiones bajan proporcionalmente
# ... otros campos necesarios
)
# ROI con los nuevos costes
roi_scenario = a.roi(new_data=new_data)
# Optimización con los nuevos costes
result_scenario = opt.optimize(budget=1_000_000, new_data=new_data)
```
#### 29.3 Método auxiliar `create_optimization_tensors`
```python
# Para especificar directamente el costo por unidad de medios
opt_tensors = opt.create_optimization_tensors(
media_units=expected_impressions_future, # impresiones proyectadas
cost_per_media_unit=new_cpms, # CPMs futuros
)
result_future = opt.optimize(budget=2_000_000, new_data=opt_tensors)
```
#### 29.4 Por qué Meridian no hace predicciones del resultado total
Meridian predice el **resultado incremental** (atribuible a medios), pero **no** el resultado total futuro. Para proyectar el resultado total, se necesitaría también modelar el baseline futuro (demanda orgánica), que depende de factores macroeconómicos, estacionalidad futura, etc., fuera del alcance del MMM.
---
### 30. Post-modelado: Depuración del Modelo
**Fuente:** `https://developers.google.com/meridian/docs/post-modeling/model-debugging?hl=es-419`
#### 30.1 Problema: No convergencia MCMC (R-hat elevado)
**Causas y soluciones en orden de prioridad:**
1. **Aumentar iteraciones:**
```python
mmm.sample_posterior(
n_chains=4,
n_adapt=2000, # aumentar de 1000 a 2000
n_burnin=2000, # aumentar de 1000 a 2000
n_keep=2000 # aumentar para más muestras
)
```
2. **Verificar identificabilidad:**
- ¿Hay variables de medios o controles altamente multicolineales?
- ¿La variación en los datos de medios es tan baja que es difícil estimar el efecto?
- ¿Alguna variable de control está perfectamente colineal con el tiempo? (→ usar `knots < n_times`)
- ¿Hay canales muy dispersos (pocas geos con ejecución, muchos periodos sin datos)?
3. **Revisar priors:**
- Priors poco informativos dificultan la convergencia cuando hay pocos datos
- Priors muy informativos también pueden causar problemas de convergencia en algunos casos
- Para KPI monetario: usar consejos de calibración de ROI
- Para KPI no monetario: reducir std del prior de contribución total
4. **Reducir complejidad:**
```python
model_spec = spec.ModelSpec(
knots=26, # reducir nudos
unique_sigma_for_each_geo=False, # compartir sigma entre geos
# ...
)
```
5. **Verificar datos:** ¿El orden de `population` coincide con el de `media` para las geos?
6. **Precisión 64-bit (solo JAX):**
```python
from jax import config
config.update("jax_enable_x64", True)
```
#### 30.2 Problema: ResourceExhaustedError (sin memoria GPU)
```python
# En lugar de n_chains=10 (paralelo):
mmm.sample_posterior(n_chains=[5, 5], ...) # 2 llamadas secuenciales de 5 cadenas
# Nota: [5,5] tarda el doble que 10. [4,3,3] tarda el triple.
```
#### 30.3 Problema: Posterior = Prior (el modelo no aprende)
**Causas:**
- Canal con inversión muy baja (poca señal en los datos)
- Alta correlación entre canales (datos no distinguen efectos individuales)
- Prior demasiado informativo relativo a los datos
**Interpretación correcta:** Si los datos tienen poca información, que posterior ≈ prior es estadísticamente correcto. No significa que el modelo esté mal — significa que los datos no son suficientes para actualizar la creencia inicial.
**Acciones:**
- Combinar el canal con otro canal relacionado (más señal combinada)
- Si la inversión es verdaderamente insignificante, considerar eliminar el canal como último recurso
- Verificar que los priors sean razonables (si son poco informativos Y los datos tienen poca info → posterior muy amplio)
#### 30.4 Problema: ROI muy diferente según el tipo de prior usado
Cuando se usan priors de `beta` (coeficiente) en lugar de `roi`:
- Las distribuciones a posteriori del ROI **no están regularizadas hacia la misma distribución** para todos los canales
- El mismo valor de `beta` implica ROIs distintos para canales con diferente escala de datos
- En situaciones de poca información: priors de `beta` generan ROIs diferentes entre canales sin que los datos lo justifiquen
**Solución:** Usar `media_prior_type='roi'` (default) en lugar de `'coefficient'`.
#### 30.5 Problema: Contribución de medios orgánicos muy alta
```python
# Si media_effects_dist='log_normal' y la contribución es inesperadamente alta:
# El default HalfNormal(5.0) puede concentrar demasiada densidad lejos de cero
prior = prior_distribution.PriorDistribution(
# Opción 1: HalfNormal más ajustado
beta_om=tfp.distributions.HalfNormal(scale=0.1),
# Opción 2: Normal (permite establecer ubicación y escala)
beta_om=tfp.distributions.Normal(loc=0.0, scale=3.0)
)
```
#### 30.6 Problema: Error de control con varianza constante
```
Error: "Control variable X does not vary across geos"
```
**Causa:** Variable de control a nivel nacional (sin variación geográfica) + `knots = n_times` → colinealidad perfecta.
**Solución:** Elegir entre:
- `knots < n_times` (ej: `knots=26`)
- Eliminar la variable de control nacional (si los nudos la reemplazan)
#### 30.7 Problema: R² negativo
Un R² negativo indica que las predicciones del modelo son **peores** que simplemente usar la media del KPI. Causas:
- Prior muy informativo que entra en conflicto con los datos
- Si el conflicto es intencional (prior basado en experimento para corregir sesgo), el R² negativo puede ser aceptable
```
Acción: Si no es intencional → flexibilizar priors (aumentar std)
```
---
### 31. Post-modelado: Actualización del Modelo
**Fuente:** `https://developers.google.com/meridian/docs/post-modeling/refreshing-model?hl=es-419`
#### 31.1 Frecuencia recomendada de actualización
- **Trimestral o anual** es lo más común
- Elegir frecuencia que coincida con el ciclo de toma de decisiones de presupuesto
- El modelo se puede actualizar con cualquier frecuencia; no hay restricción técnica
#### 31.2 Opción recomendada: Agregar datos nuevos a los existentes
```python
# Estrategia: concatenar datos nuevos con datos históricos
import numpy as np
# Datos originales: 104 semanas (2 años)
# Datos nuevos: 13 semanas (1 trimestre)
kpi_updated = np.concatenate([kpi_original, kpi_new], axis=1) # [G, 117]
media_updated = np.concatenate([media_original, media_new], axis=1)
controls_updated = np.concatenate([controls_original, controls_new], axis=1)
# Si el periodo total supera 2-3 años, considerar descartar datos más antiguos
# Tradeoff: más datos → menos varianza pero potencial sesgo si efectividad cambió
kpi_rolling = kpi_updated[:, -104:] # mantener solo las últimas 104 semanas
```
#### 31.3 Consistencia de nudos entre actualizaciones (AKS Hybrid)
Al actualizar con AKS, los nudos podrían cambiar completamente entre modelos, dificultando la comparación. La **selección híbrida** garantiza consistencia:
```python
from meridian.model import knots as knots_module
# Nudos del modelo anterior: [0, 13, 26, 52, 78, 104]
previous_knots = [0, 13, 26, 52, 78, 104]
# Al actualizar (datos hasta semana 117):
aks_updated = knots_module.AKS(input_data_updated).automatic_knot_selection(
required_knots=previous_knots, # conservar todos los nudos anteriores
restrict_to_right_of_required_knots=True # AKS solo añade nudos a la derecha del último
)
model_spec_updated = spec.ModelSpec(knots=aks_updated)
```
#### 31.4 Opción alternativa: Modelar solo datos nuevos (no recomendada)
Ajustar un modelo **solo** con datos nuevos (ej: 1 trimestre) tiene estos problemas:
- El efecto de Adstock no se modela correctamente en los primeros periodos (falta la ventana previa)
- Con tan pocos datos, el modelo será casi idéntico al prior (posterior ≈ prior)
- Las interdependencias entre parámetros se pierden si se usa la posterior del modelo anterior como prior del nuevo (solo captura distribuciones marginales, no la conjunta)
**Cuándo podría ser válido:** Si hay suficientes datos (>20 periodos) en la ventana nueva y se incluye la ventana previa de medios para Adstock.
#### 31.5 Uso de resultados anteriores como priors (con precaución)
```python
# Si el modelo anterior tiene posterior_roi_mean=[1.8, 2.2, 1.5]:
# Se puede usar como prior del modelo nuevo, PERO:
# ⚠️ Esto cuenta los datos anteriores DOS VECES (sesgo)
# Solo es razonable cuando:
# 1. Los datos nuevos son muy pocos (<10 periodos)
# 2. Se tiene confianza alta en la estabilidad de los efectos de medios
prior_informed = prior_distribution.PriorDistribution(
roi_m=prior_distribution.PriorDistribution.lognormal_dist_from_mean_std(
mean=[1.8, 2.2, 1.5], # medias del modelo anterior
std=[0.6, 0.7, 0.5] # std más amplio para no sobre-regularizar
)
)
```
---
## APÉNDICE: RESUMEN RÁPIDO DE REFERENCIAS
### URLs consultadas y su estado de accesibilidad
| URL | Estado | Alternativa usada |
|---|---|---|
| `github.com/google/meridian` (README) | ✅ Accesible via raw GitHub | `raw.githubusercontent.com/google/meridian/main/README.md` |
| `developers.google.com/meridian/reference/api/meridian` | ❌ Solo devuelve footer | Código fuente + docs `/docs/` |
| `developers.google.com/meridian/reference/api/proto` | ✅ Parcial | — |
| `developers.google.com/meridian/notebook?hl=es-419` | ❌ Solo devuelve footer | README + estructura de repo |
| `developers.google.com/meridian/notebook/meridian-getting-started` | ✅ | — |
| `colab.research.google.com/github/google/meridian/blob/main/demo/*.ipynb` | ❌ Requiere auth | `raw.githubusercontent.com/google/meridian/main/demo/*.ipynb` |
| Todas las páginas `developers.google.com/meridian/docs/` | ✅ La mayoría accesibles | — |
### Flujo de trabajo recomendado
```
1. PREPARACIÓN (pre-modeling)
├── Recolectar datos: KPI semanal por geografía (2-3 años)
├── Preparar medios: impresiones + gasto por canal, geo, semana
├── Preparar controles: estacionalidad, eventos, GQV para SEM
├── EDA: verificar correlaciones, VIF, varianza del KPI
└── Evaluar cantidad de datos vs. número de parámetros
2. ESPECIFICACIÓN DEL MODELO
├── Elegir tipo de prior: 'roi' si se tienen experimentos, 'contribution' si KPI no monetario
├── Calibrar priors: lognormal_dist_from_mean_std() con valores de experimentos/benchmarks
├── Configurar knots: enable_aks=True (recomendado) o valor fijo
├── Configurar max_lag: 8 semanas (default), ajustar si canal tiene efectos largos
└── Decidir national vs. geo model
3. AJUSTE DEL MODELO
├── mmm.sample_posterior(n_chains=4, n_adapt=1000, n_burnin=1000, n_keep=1000)
├── Verificar convergencia: R-hat < 1.2 para todos los parámetros
└── GPU recomendada (T4 mínimo)
4. DIAGNÓSTICO POST-MODELADO
├── Health Score: objetivo ≥ 90
├── PPP: debe ser ≥ 0.05
├── P(baseline < 0): debe ser < 0.2
├── Shift prior→posterior: verificar que el modelo aprende
└── Curvas de Hill/Adstock: prior vs. posterior coherentes
5. RESULTADOS E INTERPRETACIÓN
├── ROI por canal con intervalos creíbles al 90%
├── mROI: identificar canales sobre/bajo-invertidos
├── Curvas de respuesta: identificar puntos de saturación
└── Waterfall de contribuciones: baseline vs. canales individuales
6. OPTIMIZACIÓN DE PRESUPUESTO
├── Definir escenario: presupuesto fijo o flexible
├── Establecer restricciones por canal (±50% del histórico)
├── Interpretar: círculo (actual) vs. cuadrado (óptimo) en curvas de respuesta
└── Para R&F: calcular frecuencia óptima primero
7. ACTUALIZACIÓN PERIÓDICA
├── Frecuencia: trimestral o anual
├── Agregar datos nuevos a histórico (no modelar solo nuevos datos)
├── Usar AKS Hybrid para consistencia de nudos entre actualizaciones
└── Documentar cambios en priors y razones de negocio
```
---
*Documento generado a partir de investigación directa de: repositorio GitHub `google/meridian`, documentación oficial `developers.google.com/meridian/docs/` (todas las secciones: pre-modeling, advanced-modeling, post-modeling), notebooks demo (5 notebooks en `raw.githubusercontent.com`), y CHANGELOG + pyproject.toml para detalles de versión. Versión Meridian: 1.8.0. Fecha de referencia: agosto 2026.*
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |