SoftPlusHSGP

class pymc_marketing.mmm.hsgp.SoftPlusHSGP(**data)

HSGP con transformación softplus.

El uso de la transformación softplus mapea el GP latente a valores positivos. Luego, normalizamos multiplicativamente por la media temporal para que el multiplicador resultante tenga una media de 1 en la primera dimensión, manteniéndose estrictamente positivo.

Ejemplos

Literatura recomendada para la configuración de SoftPlusHSGP:

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt

from pymc_marketing.mmm import SoftPlusHSGP

seed = sum(map(ord, "Out of the box GP"))
rng = np.random.default_rng(seed)

n = 52
X = np.arange(n)

hsgp = SoftPlusHSGP.parameterize_from_data(
    X=X,
    dims="time",
)

dates = pd.date_range("2022-01-01", periods=n, freq="W-MON")
coords = {
    "time": dates,
}
prior = hsgp.sample_prior(coords=coords, random_seed=rng)
curve = prior["f"]
hsgp.plot_curve(curve, random_seed=rng)
plt.show()

(Source code, png, hires.png, pdf)

Nuevas predicciones de datos con SoftPlusHSGP

Nota

Al realizar las predicciones, el modelo necesita ser transformado para mantener los datos centrados alrededor de 1. Hay una función auxiliar pymc_marketing.model_graph.deterministics_to_flat() que se puede utilizar para transformar el modelo al realizar predicciones fuera de muestra.

Esta transformación se maneja automáticamente en los MMMs proporcionados.

import numpy as np
import pandas as pd

import pymc as pm

import matplotlib.pyplot as plt

from pymc_marketing.mmm import SoftPlusHSGP
from pymc_marketing.model_graph import deterministics_to_flat
from pymc_extras.prior import Prior

seed = sum(map(ord, "New data predictions with SoftPlusHSGP"))
rng = np.random.default_rng(seed)

eta = Prior("Exponential", lam=1)
ls = Prior("InverseGamma", alpha=2, beta=1)
hsgp = SoftPlusHSGP(
    eta=eta,
    ls=ls,
    m=20,
    L=150,
    dims=("time", "channel"),
)

n = 52
X = np.arange(n)

channels = ["A", "B", "C"]
dates = pd.date_range("2022-01-01", periods=n, freq="W-MON")
coords = {"time": dates, "channel": channels}
with pm.Model(coords=coords) as model:
    data = pm.Data("data", X, dims="time")
    hsgp.register_data(data).create_variable("f")
    idata = pm.sample_prior_predictive(random_seed=rng)

prior = idata.prior

n_new = 10
X_new = np.arange(n - 1 , n + n_new)
last_date = dates[-1]
new_dates = pd.date_range(last_date, periods=n_new + 1, freq="W-MON")

with deterministics_to_flat(model, hsgp.deterministics_to_replace("f")):
    pm.set_data(
        new_data={
            "data": X_new,
        },
        coords={"time": new_dates},
    )
    post = pm.sample_posterior_predictive(
        prior,
        var_names=["f"],
        random_seed=rng,
    )

chain, draw = 0, rng.choice(prior.sizes["draw"])
colors = [f"C{i}" for i in range(len(channels))]

def get_sample(curve):
    return curve.loc[chain, draw].to_series().unstack()

ax = prior["f"].pipe(get_sample).plot(color=colors)
post.posterior_predictive["f"].pipe(get_sample).plot(
    ax=ax, color=colors, linestyle="--", legend=False
)
ax.set(xlabel="time", ylabel="f", title="New data predictions")
plt.show()

(Source code)

Métodos

SoftPlusHSGP.__init__(**data)	Cree un nuevo modelo analizando y validando los datos de entrada de los argumentos de palabra clave.
SoftPlusHSGP.construct([_fields_set])
SoftPlusHSGP.copy(*[, incluir, excluir, ...])	Devuelve una copia del modelo.
SoftPlusHSGP.create_variable(name[, xdist])	Cree la variable.
SoftPlusHSGP.deterministics_to_replace(nombre)	Nombre de las variables determinísticas que se reemplazan con pm.Flat para fuera de muestra.
SoftPlusHSGP.dict(*[, incluir, excluir, ...])
SoftPlusHSGP.from_dict(datos)	Cree un objeto a partir de un diccionario.
SoftPlusHSGP.from_orm(obj)
SoftPlusHSGP.json(*[, incluir, excluir, ...])
SoftPlusHSGP.model_construct([_fields_set])	Crea una nueva instancia de la clase Model con datos validados.
SoftPlusHSGP.model_copy(*[, actualizar, profundo])	!!! abstract "Documentación de Uso"
SoftPlusHSGP.model_dump(*[, modo, incluir, ...])	!!! abstract "Documentación de Uso"
SoftPlusHSGP.model_dump_json(*[, indent, ...])	!!! abstract "Documentación de Uso"
SoftPlusHSGP.model_json_schema([por_alias, ...])	Genera un esquema JSON para una clase de modelo.
SoftPlusHSGP.model_parametrized_name(params)	Calcule el nombre de la clase para parametrizaciones de clases genéricas.
SoftPlusHSGP.model_post_init(contexto, /)	Sobrescriba este método para realizar una inicialización adicional después de __init__ y model_construct.
SoftPlusHSGP.model_rebuild(*[, forzar, ...])	Intente reconstruir el esquema de pydantic-core para el modelo.
SoftPlusHSGP.model_validate(obj, *[, ...])	Valide una instancia del modelo pydantic.
SoftPlusHSGP.model_validate_json(json_data, *)	!!! abstract "Documentación de Uso"
SoftPlusHSGP.model_validate_strings(obj, *)	Valide el objeto dado con datos de cadena contra el modelo de Pydantic.
SoftPlusHSGP.parameterize_from_data(X, dims)	Cree un HSGP informado por los datos con recomendaciones basadas en la literatura.
SoftPlusHSGP.parse_file(ruta, *[, ...])
SoftPlusHSGP.parse_obj(obj)
SoftPlusHSGP.parse_raw(b, *[, tipo_de_contenido, ...])
SoftPlusHSGP.plot_curve(curve[, n_samples, ...])	Dibuje la curva.
SoftPlusHSGP.register_data(X)	Registre los datos que se utilizarán en el modelo.
SoftPlusHSGP.sample_prior([coords])	Muestra de la distribución previa.
SoftPlusHSGP.schema([por_alias, ref_template])
SoftPlusHSGP.schema_json(*[, por_alias, ...])
SoftPlusHSGP.to_dict()	Convierte el objeto a un diccionario.
SoftPlusHSGP.update_forward_refs(**localns)
SoftPlusHSGP.validate(valor)

Atributos

model_computed_fields
model_config	Configuración para el modelo, debe ser un diccionario que se ajuste a [ConfigDict][pydantic.config.ConfigDict].
model_extra	Obtener campos adicionales establecidos durante la validación.
model_fields
model_fields_set	Devuelve el conjunto de campos que han sido establecidos explícitamente en esta instancia del modelo.
ls
eta
L
centered
drop_first
cov_func
m
X
X_mid
dims
transform
demeaned_basis