From 31ce2f2ae792f8da9706b2daaf54a6c8cd4d7d17 Mon Sep 17 00:00:00 2001 From: Jesse Grabowski Date: Fri, 6 Dec 2024 20:14:00 +0800 Subject: [PATCH 1/9] initial commit --- pymc_experimental/model/modular/__init__.py | 0 pymc_experimental/model/modular/components.py | 590 ++++++++++++++++++ pymc_experimental/model/modular/likelihood.py | 359 +++++++++++ pymc_experimental/model/modular/utilities.py | 276 ++++++++ 4 files changed, 1225 insertions(+) create mode 100644 pymc_experimental/model/modular/__init__.py create mode 100644 pymc_experimental/model/modular/components.py create mode 100644 pymc_experimental/model/modular/likelihood.py create mode 100644 pymc_experimental/model/modular/utilities.py diff --git a/pymc_experimental/model/modular/__init__.py b/pymc_experimental/model/modular/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py new file mode 100644 index 00000000..16315285 --- /dev/null +++ b/pymc_experimental/model/modular/components.py @@ -0,0 +1,590 @@ +from abc import ABC, abstractmethod +from collections.abc import Sequence +from typing import Literal, get_args + +import pandas as pd +import pymc as pm +import pytensor.tensor as pt + +from model.modular.utilities import ColumnType, hierarchical_prior_to_requested_depth +from patsy import dmatrix + +POOLING_TYPES = Literal["none", "complete", "partial"] +valid_pooling = get_args(POOLING_TYPES) + +CURVE_TYPES = Literal["log", "abc", "ns", "nss", "box-cox"] +valid_curves = get_args(CURVE_TYPES) + + +FEATURE_DICT = { + "log": ["slope"], + "box-cox": ["lambda", "slope", "intercept"], + "nss": ["tau", "beta0", "beta1", "beta2"], + "abc": ["a", "b", "c"], +} + + +def _validate_pooling_params(pooling_columns: ColumnType, pooling: POOLING_TYPES): + """ + Helper function to validate inputs to a GLM component. + + Parameters + ---------- + index_data: Series or DataFrame + Index data used to build hierarchical priors + + pooling: str + Type of pooling to use in the component + + Returns + ------- + None + """ + if pooling_columns is not None and pooling == "complete": + raise ValueError("Index data provided but complete pooling was requested") + if pooling_columns is None and pooling != "complete": + raise ValueError( + "Index data must be provided for partial pooling (pooling = 'partial') or no pooling " + "(pooling = 'none')" + ) + + +def _get_x_cols( + cols: str | Sequence[str], + model: pm.Model | None = None, +) -> pt.TensorVariable: + model = pm.modelcontext(model) + # Don't upcast a single column to a colum matrix + if isinstance(cols, str): + [cols_idx] = [i for i, col in enumerate(model.coords["feature"]) if col == cols] + else: + cols_idx = [i for i, col in enumerate(model.coords["feature"]) if col is cols] + return model["X_data"][:, cols_idx] + + +class GLMModel(ABC): + """Base class for GLM components. Subclasses should implement the build method to construct the component.""" + + def __init__(self): + self.model = None + self.compiled = False + + @abstractmethod + def build(self, model=None): + pass + + def __add__(self, other): + return AdditiveGLMComponent(self, other) + + def __mul__(self, other): + return MultiplicativeGLMComponent(self, other) + + +class AdditiveGLMComponent(GLMModel): + """Class to represent an additive combination of GLM components""" + + def __init__(self, left, right): + self.left = left + self.right = right + super().__init__() + + def build(self, *args, **kwargs): + return self.left.build(*args, **kwargs) + self.right.build(*args, **kwargs) + + +class MultiplicativeGLMComponent(GLMModel): + """Class to represent a multiplicative combination of GLM components""" + + def __init__(self, left, right): + self.left = left + self.right = right + super().__init__() + + def build(self, *args, **kwargs): + return self.left.build(*args, **kwargs) * self.right.build(*args, **kwargs) + + +class Intercept(GLMModel): + def __init__( + self, + name: str | None = None, + *, + pooling_cols: ColumnType = None, + pooling: POOLING_TYPES = "complete", + hierarchical_params: dict | None = None, + prior: str = "Normal", + prior_params: dict | None = None, + ): + """ + TODO: Update signature docs + Class to represent an intercept term in a GLM model. + + By intercept, it is meant any constant term in the model that is not a function of any input data. This can be + a simple constant term, or a hierarchical prior that creates fixed effects across level of one or more + categorical variables. + + Parameters + ---------- + name: str, optional + Name of the intercept term. If None, a default name is generated based on the index_data. + index_data: Series or DataFrame, optional + Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as + levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, + and depth increasing to the right. + + The index of the index_data must match the index of the observed data. + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". + pooling: str, one of ["none", "complete", "partial"], default "complete" + Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the + index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated + as coming from the same group. If "partial", a hierarchical prior is constructed that shares information + across groups in the index_data. + prior_params: dict, optional + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + hierarchical_params: dict, optional + Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. + Options include: + sigma_dist: str + Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" + sigma_kwargs: dict + Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. + Default is {"alpha": 2, "beta": 1} + offset_dist: str, one of ["zerosum", "normal", "laplace"] + Name of the distribution to use for the offset distribution. Default is "zerosum" + """ + _validate_pooling_params(pooling_cols, pooling) + + self.pooling_cols = pooling_cols + self.hierarchical_params = hierarchical_params if hierarchical_params is not None else {} + self.pooling = pooling if pooling_cols is not None else "complete" + + self.prior = prior + self.prior_params = prior_params if prior_params is not None else {} + + if pooling_cols is None: + pooling_cols = [] + elif isinstance(pooling_cols, str): + pooling_cols = [pooling_cols] + + data_name = ", ".join(pooling_cols) + self.name = name or f"Constant(pooling_cols={data_name})" + super().__init__() + + def build(self, model=None): + model = pm.modelcontext(model) + with model: + if self.pooling == "complete": + intercept = getattr(pm, self.prior)(f"{self.name}", **self.prior_params) + return intercept + + [i for i, col in enumerate(model.coords["feature"]) if col in self.pooling_cols] + + intercept = hierarchical_prior_to_requested_depth( + self.name, + model.X_df[self.pooling_cols], # TODO: Reconsider this + model=model, + dims=None, + no_pooling=self.pooling == "none", + **self.hierarchical_params, + ) + return intercept + + +def build_curve( + time_pt: pt.TensorVariable, + beta: pt.TensorVariable, + curve_type: Literal["log", "abc", "ns", "nss", "box-cox"], +): + """ + Build a curve based on the time data and parameters beta. + + In this context, a "curve" is a deterministic function that maps time to a value. The curve should (in general) be + strictly increasing with time (df(t)/dt > 0), and should (in general) exhibit diminishing marginal growth with time + (d^2f(t)/dt^2 < 0). These properties are not strictly necessary; some curve functions (such as nss) allow for + local reversals. + + Parameters + ---------- + time_pt: TensorVariable + A pytensor variable representing the time data to build the curve from. + beta: TensorVariable + A pytensor variable representing the parameters of the curve. The number of parameters and their meaning depend + on the curve_type. + + .. warning:: + Currently no checks are in place to ensure that the number of parameters in beta matches the expected number + for the curve_type. + + curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] + Type of curve to build. Options are: + + - "log": + A simple log-linear curve. The curve is defined as: + + .. math:: + + \beta \\log(t) + + - "abc": + A curve parameterized by "a", "b", and "c", such that the minimum value of the curve is "a", the + maximum value is "a + b", and the inflection point is "a + b / c". "C" thus controls the speed of change + from the minimum to the maximum value. The curve is defined as: + + .. math:: + + \frac{a + bc t}{1 + ct} + + - "ns": + The Nelson-Siegel yield curve model. The curve is parameterized by three parameters: :math:`\tau`, + :math:`\beta_1`, and :math:`\beta_2`. :math:`\tau` is the decay rate of the exponential term, and + :math:`\beta_1` and :math:`\beta_2` control the slope and curvature of the curve. The curve is defined as: + + .. math:: + + \begin{align} + x_t &= \beta_1 \\phi(t) + \beta_2 \\left (\\phi(t) - \\exp(-t/\tau) \right ) \\ + \\phi(t) &= \frac{1 - \\exp(-t/\tau)}{t/\tau} + \\end{align} + + - "nss": + The Nelson-Siegel-Svensson yield curve model. The curve is parameterized by four parameters: + :math:`\tau_1`, :math:`\tau_2`, :math:`\beta_1`, and :math:`\beta_2`. :math:`\beta_3` + + Where :math:`\tau_1` and :math:`\tau_2` are the decay rates of the two exponential terms, :math:`\beta_1` + controls the slope of the curve, and :math:`\beta_2` and :math:`\beta_3` control the curvature of the curve. + To ensure that short-term rates are strictly postitive, one typically restrices :math:`\beta_1 + \beta_2 > 0`. + + The curve is defined as: + + .. math:: + \begin{align} + x_t & = \beta_1 \\phi_1(t) + \beta_2 \\left (\\phi_1(t) - \\exp(-t/\tau_1) \right) + \beta_3 \\left (\\phi_2(t) - \\exp(-t/\tau_2) \right) \\ + \\phi_1(t) &= \frac{1 - \\exp(-t/\tau_1)}{t/\tau_1} \\ + \\phi_2(t) &= \frac{1 - \\exp(-t/\tau_2)}{t/\tau_2} + \\end{align} + + Note that this definition omits the constant term that is typically included in the Nelson-Siegel-Svensson; + you are assumed to have already accounted for this with another component in the model. + + - "box-cox": + A curve that applies a box-cox transformation to the time data. The curve is parameterized by two + parameters: :math:`\\lambda` and :math:`\beta`, where :math:`\\lambda` is the box-cox parameter that + interpolates between the log and linear transformations, and :math:`\beta` is the slope of the curve. + + The curve is defined as: + + .. math:: + + \beta \\left ( \frac{t^{\\lambda} - 1}{\\lambda} \right ) + + Returns + ------- + TensorVariable + A pytensor variable representing the curve. + """ + if curve_type == "box-cox": + lam = beta[0] + 1e-12 + time_scaled = (time_pt**lam - 1) / lam + curve = beta[1] * time_scaled + + elif curve_type == "log": + time_scaled = pt.log(time_pt) + curve = beta[0] * time_scaled + + elif curve_type == "ns": + tau = pt.exp(beta[0]) + t_over_tau = time_pt / tau + time_scaled = (1 - pt.exp(-t_over_tau)) / t_over_tau + curve = beta[1] * time_scaled + beta[2] * (time_scaled - pt.exp(-t_over_tau)) + + elif curve_type == "nss": + tau = pt.exp(beta[:2]) + beta = beta[2:] + t_over_tau_1 = time_pt / tau[0] + t_over_tau_2 = time_pt / tau[1] + time_scaled_1 = (1 - pt.exp(t_over_tau_1)) / t_over_tau_1 + time_scaled_2 = (1 - pt.exp(t_over_tau_2)) / t_over_tau_2 + curve = ( + beta[0] * time_scaled_1 + + beta[1] * (time_scaled_1 - pt.exp(-t_over_tau_1)) + + beta[2] * (time_scaled_2 - pt.exp(-t_over_tau_2)) + ) + + elif curve_type == "abc": + curve = (beta[0] + beta[1] * beta[2] * time_pt) / (1 + beta[2] * time_pt) + + else: + raise ValueError(f"Unknown curve type: {curve_type}") + + return curve + + +class Curve(GLMModel): + def __init__( + self, + name: str, + t: pd.Series | pd.DataFrame, + prior: str = "Normal", + index_data: pd.Series | pd.DataFrame | None = None, + pooling: POOLING_TYPES = "complete", + curve_type: CURVE_TYPES = "log", + prior_params: dict | None = None, + hierarchical_params: dict | None = None, + ): + """ + Class to represent a curve in a GLM model. + + A curve is a deterministic function that transforms time data via a non-linear function. Currently, the following + curve types are supported: + - "log": A simple log-linear curve. + - "abc": A curve defined by a minimum value (a), maximum value (b), and inflection point ((a + b) / c). + - "ns": The Nelson-Siegel yield curve model. + - "nss": The Nelson-Siegel-Svensson yield curve model. + - "box-cox": A curve that applies a box-cox transformation to the time data. + + Parameters + ---------- + name: str, optional + Name of the intercept term. If None, a default name is generated based on the index_data. + t: Series + Time data used to build the curve. If Series, must have a name attribute. If dataframe, must have exactly + one column. + index_data: Series or DataFrame, optional + Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as + levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, + and depth increasing to the right. + + The index of the index_data must match the index of the observed data. + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". + pooling: str, one of ["none", "complete", "partial"], default "complete" + Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the + index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated + as coming from the same group. If "partial", a hierarchical prior is constructed that shares information + across groups in the index_data. + curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] + Type of curve to build. For details, see the build_curve function. + prior_params: dict, optional + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + hierarchical_params: dict, optional + Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. + Options include: + sigma_dist: str + Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" + sigma_kwargs: dict + Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. + Default is {"alpha": 2, "beta": 1} + offset_dist: str, one of ["zerosum", "normal", "laplace"] + Name of the distribution to use for the offset distribution. Default is "zerosum" + """ + + _validate_pooling_params(index_data, pooling) + + self.name = name + self.t = t if isinstance(t, pd.Series) else t.iloc[:, 0] + self.curve_type = curve_type + + self.index_data = index_data + self.pooling = pooling + + self.prior = prior + self.prior_params = prior_params if prior_params is not None else {} + self.hierarchical_params = hierarchical_params if hierarchical_params is not None else {} + + super().__init__() + + def build(self, model=None): + model = pm.modelcontext(model) + obs_dim = self.t.index.name + feature_dim = f"{self.name}_features" + if feature_dim not in model.coords: + model.add_coord(feature_dim, FEATURE_DICT[self.curve_type]) + + with model: + t_pt = pm.Data("t", self.t.values, dims=[obs_dim]) + if self.pooling == "complete": + beta = getattr(pm, self.prior)( + f"{self.name}_beta", **self.prior_params, dims=[feature_dim] + ) + curve = build_curve(t_pt, beta, self.curve_type) + return pm.Deterministic(f"{self.name}", curve, dims=[obs_dim]) + + beta = hierarchical_prior_to_requested_depth( + self.name, + self.index_data, + model=model, + dims=[feature_dim], + no_pooling=self.pooling == "none", + ) + + curve = build_curve(t_pt, beta, self.curve_type) + return pm.Deterministic(f"{self.name}", curve, dims=[obs_dim]) + + +class Regression(GLMModel): + def __init__( + self, + name: str, + X: pd.DataFrame, + prior: str = "Normal", + index_data: pd.Series = None, + pooling: POOLING_TYPES = "complete", + **prior_params, + ): + """ + Class to represent a regression component in a GLM model. + + A regression component is a linear combination of input data and a set of parameters. The input data should be + a DataFrame with the same index as the observed data. Parameteres can be made hierarchical by providing + an index_data Series or DataFrame (which should have the same index as the observed data). + + Parameters + ---------- + name: str, optional + Name of the intercept term. If None, a default name is generated based on the index_data. + X: DataFrame + Exogenous data used to build the regression component. Each column of the DataFrame represents a feature + used in the regression. Index of the DataFrame should match the index of the observed data. + index_data: Series or DataFrame, optional + Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as + levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, + and depth increasing to the right. + + The index of the index_data must match the index of the observed data. + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". + pooling: str, one of ["none", "complete", "partial"], default "complete" + Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the + index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated + as coming from the same group. If "partial", a hierarchical prior is constructed that shares information + across groups in the index_data. + curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] + Type of curve to build. For details, see the build_curve function. + prior_params: dict, optional + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + hierarchical_params: dict, optional + Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. + Options include: + sigma_dist: str + Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" + sigma_kwargs: dict + Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. + Default is {"alpha": 2, "beta": 1} + offset_dist: str, one of ["zerosum", "normal", "laplace"] + Name of the distribution to use for the offset distribution. Default is "zerosum" + """ + _validate_pooling_params(index_data, pooling) + + self.name = name + self.X = X + self.index_data = index_data + self.pooling = pooling + + self.prior = prior + self.prior_params = prior_params + + super().__init__() + + def build(self, model=None): + model = pm.modelcontext(model) + feature_dim = f"{self.name}_features" + obs_dim = self.X.index.name + + if feature_dim not in model.coords: + model.add_coord(feature_dim, self.X.columns) + + with model: + X_pt = pm.Data(f"{self.name}_data", self.X.values, dims=[obs_dim, feature_dim]) + if self.pooling == "complete": + beta = getattr(pm, self.prior)( + f"{self.name}", **self.prior_params, dims=[feature_dim] + ) + return X_pt @ beta + + beta = hierarchical_prior_to_requested_depth( + self.name, + self.index_data, + model=model, + dims=[feature_dim], + no_pooling=self.pooling == "none", + ) + + regression_effect = (X_pt * beta.T).sum(axis=-1) + return regression_effect + + +class Spline(Regression): + def __init__( + self, + name: str, + n_knots: int = 10, + spline_data: pd.Series | pd.DataFrame | None = None, + prior: str = "Normal", + index_data: pd.Series | None = None, + pooling: POOLING_TYPES = "complete", + **prior_params, + ): + """ + Class to represent a spline component in a GLM model. + + A spline component is a linear combination of basis functions that are piecewise polynomial. The basis functions + are constructed using the `bs` function from the patsy library. The spline_data should be a Series with the same + index as the observed data. + + The weights of the spline components can be made hierarchical by providing an index_data Series or DataFrame + (which should have the same index as the observed data). + + Parameters + ---------- + name: str, optional + Name of the intercept term. If None, a default name is generated based on the index_data. + n_knots: int, default 10 + Number of knots to use in the spline basis. + spline_data: Series or DataFrame + Exogenous data to be interpolated using basis splines. If Series, must have a name attribute. If dataframe, + must have exactly one column. In either case, the index of the data should match the index of the observed + data. + index_data: Series or DataFrame, optional + Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as + levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, + and depth increasing to the right. + + The index of the index_data must match the index of the observed data. + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". + pooling: str, one of ["none", "complete", "partial"], default "complete" + Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the + index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated + as coming from the same group. If "partial", a hierarchical prior is constructed that shares information + across groups in the index_data. + curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] + Type of curve to build. For details, see the build_curve function. + prior_params: dict, optional + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + hierarchical_params: dict, optional + Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. + Options include: + sigma_dist: str + Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" + sigma_kwargs: dict + Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. + Default is {"alpha": 2, "beta": 1} + offset_dist: str, one of ["zerosum", "normal", "laplace"] + Name of the distribution to use for the offset distribution. Default is "zerosum" + """ + _validate_pooling_params(index_data, pooling) + + spline_features = dmatrix( + f"bs(maturity_years, df={n_knots}, degree=3) - 1", + {"maturity_years": spline_data}, + ) + X = pd.DataFrame( + spline_features, + index=spline_data.index, + columns=[f"Spline_{i}" for i in range(n_knots)], + ) + + super().__init__( + name=name, X=X, prior=prior, index_data=index_data, pooling=pooling, **prior_params + ) diff --git a/pymc_experimental/model/modular/likelihood.py b/pymc_experimental/model/modular/likelihood.py new file mode 100644 index 00000000..32b4f432 --- /dev/null +++ b/pymc_experimental/model/modular/likelihood.py @@ -0,0 +1,359 @@ +from abc import ABC, abstractmethod +from collections.abc import Sequence +from typing import Literal, get_args + +import arviz as az +import pandas as pd +import pymc as pm +import pytensor.tensor as pt + +from pymc.backends.arviz import apply_function_over_dataset +from pymc.model.fgraph import clone_model +from pymc.pytensorf import reseed_rngs +from pytensor.tensor.random.type import RandomType + +from pymc_experimental.model.marginal.marginal_model import MarginalModel +from pymc_experimental.model.modular.utilities import ColumnType + +LIKELIHOOD_TYPES = Literal["lognormal", "logt", "mixture", "unmarginalized-mixture"] +valid_likelihoods = get_args(LIKELIHOOD_TYPES) + + +class Likelihood(ABC): + """Class to represent a likelihood function for a GLM component. Subclasses should implement the _get_model_class + method to return the type of model used by the likelihood function, and should implement a `register_xx` method for + each parameter unique to that likelihood function.""" + + def __init__(self, target_col: ColumnType, data: pd.DataFrame): + """ + Initialization logic common to all likelihoods. + + All subclasses should call super().__init__(y) to register data and create a model object. The subclass __init__ + method should then create a PyMC model inside the self.model context. + + Parameters + ---------- + y: Series or DataFrame, optional + Observed data. Must have a name attribute (if a Series), and an index with a name attribute. + """ + + if not isinstance(target_col, str): + [target_col] = target_col + self.target_col = target_col + + # TODO: Reconsider this (two sources of nearly the same info not good) + X_df = data.drop(columns=[target_col]) + X_data = X_df.copy() + self.column_labels = {} + for col, dtype in X_data.dtypes.to_dict().items(): + if dtype.name.startswith("float"): + pass + elif dtype.name == "object": + # TODO: We definitely need to save these if we want to factorize predict data + col_array, labels = pd.factorize(X_data[col], sort=True) + X_data[col] = col_array.astype("float64") + self.column_labels[col] = {label: i for i, label in enumerate(labels.values)} + elif dtype.name.startswith("int"): + X_data[col] = X_data[col].astype("float64") + else: + raise NotImplementedError( + f"Haven't decided how to handle the following type: {dtype.name}" + ) + + self.obs_dim = data.index.name + coords = { + self.obs_dim: data.index.values, + "feature": list(X_data.columns), + } + with self._get_model_class(coords) as self.model: + self.model.X_df = X_df # FIXME: Definitely not a solution + pm.Data(f"{target_col}_observed", data[target_col], dims=self.obs_dim) + pm.Data( + "X_data", + X_data, + dims=(self.obs_dim, "feature"), + shape=(None, len(coords["feature"])), + ) + + self._predict_fn = None # We are caching function for faster predictions + + def sample(self, **sample_kwargs): + with self.model: + return pm.sample(**sample_kwargs) + + def predict( + self, + idata: az.InferenceData, + predict_df: pd.DataFrame, + random_seed=None, + compile_kwargs=None, + ): + # Makes sure only features present during fitting are used and sorted during prediction + X_data = predict_df[list(self.model.coords["feature"])].copy() + for col, dtype in X_data.dtypes.to_dict().items(): + if dtype.name.startswith("float"): + pass + elif dtype.name == "object": + X_data[col] = X_data[col].map(self.column_labels[col]).astype("float64") + elif dtype.name.startswith("int"): + X_data[col] = X_data[col].astype("float64") + else: + raise NotImplementedError( + f"Haven't decided how to handle the following type: {dtype.name}" + ) + + coords = {self.obs_dim: X_data.index.values} + + predict_fn = self._predict_fn + + if predict_fn is None: + model_copy = clone_model(self.model) + # TODO: Freeze everything that is not supposed to change, when PyMC allows it + # dims = [dim for dim self.model.coords.keys() if dim != self.obs_dim] + # model_copy = freeze_dims_and_data(model_copy, dims=dims, data=[]) + observed_RVs = model_copy.observed_RVs + if compile_kwargs is None: + compile_kwargs = {} + predict_fn = model_copy.compile_fn( + observed_RVs, + inputs=model_copy.free_RVs, + mode=compile_kwargs.pop("mode", None), + on_unused_input="ignore", + **compile_kwargs, + ) + predict_fn.trust_input = True + self._predict_fn = predict_fn + + [X_var] = [shared for shared in predict_fn.f.get_shared() if shared.name == "X_data"] + if random_seed is not None: + rngs = [ + shared + for shared in predict_fn.f.get_shared() + if isinstance(shared.type, RandomType) + ] + reseed_rngs(rngs, random_seed) + X_var.set_value(X_data.values, borrow=True) + + return apply_function_over_dataset( + fn=predict_fn, + dataset=idata.posterior[[rv.name for rv in self.model.free_RVs]], + output_var_names=[rv.name for rv in self.model.observed_RVs], + dims={rv.name: [self.obs_dim] for rv in self.model.observed_RVs}, + coords=coords, + progressbar=False, + ) + + @abstractmethod + def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: + """Return the type on model used by the likelihood function""" + raise NotImplementedError + + def register_mu( + self, + *, + df: pd.DataFrame, + mu=None, + ): + with self.model: + if mu is not None: + return pm.Deterministic("mu", mu.build(df=df), dims=[self.obs_dim]) + return pm.Normal("mu", 0, 100) + + def register_sigma( + self, + *, + df: pd.DataFrame, + sigma=None, + ): + with self.model: + if sigma is not None: + return pm.Deterministic("sigma", pt.exp(sigma.build(df=df)), dims=[self.obs_dim]) + return pm.Exponential("sigma", lam=1) + + +class LogNormalLikelihood(Likelihood): + """Class to represent a log-normal likelihood function for a GLM component.""" + + def __init__( + self, + mu, + sigma, + target_col: ColumnType, + data: pd.DataFrame, + ): + super().__init__(target_col=target_col, data=data) + + with self.model: + self.register_data(data[target_col]) + mu = self.register_mu(mu) + sigma = self.register_sigma(sigma) + + pm.LogNormal( + target_col, + mu=mu, + sigma=sigma, + observed=self.model[f"{target_col}_observed"], + dims=[self.obs_dim], + ) + + def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: + return pm.Model(coords=coords) + + +class LogTLikelihood(Likelihood): + """ + Class to represent a log-t likelihood function for a GLM component. + """ + + def __init__( + self, + mu, + *, + sigma=None, + nu=None, + target_col: ColumnType, + data: pd.DataFrame, + ): + def log_student_t(nu, mu, sigma, shape=None): + return pm.math.exp(pm.StudentT.dist(mu=mu, sigma=sigma, nu=nu, shape=shape)) + + super().__init__(target_col=target_col, data=data) + + with self.model: + mu = self.register_mu(mu=mu, df=data) + sigma = self.register_sigma(sigma=sigma, df=data) + nu = self.register_nu(nu=nu, df=data) + + pm.CustomDist( + target_col, + nu, + mu, + sigma, + observed=self.model[f"{target_col}_observed"], + shape=mu.shape, + dims=[self.obs_dim], + dist=log_student_t, + class_name="LogStudentT", + ) + + def register_nu(self, *, df, nu=None): + with self.model: + if nu is not None: + return pm.Deterministic("nu", pt.exp(nu.build(df=df)), dims=[self.obs_dim]) + return pm.Uniform("nu", 2, 30) + + def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: + return pm.Model(coords=coords) + + +class BaseMixtureLikelihood(Likelihood): + """ + Base class for mixture likelihood functions to hold common methods for registering parameters. + """ + + def register_sigma(self, *, df, sigma=None): + with self.model: + if sigma is None: + sigma_not_outlier = pm.Exponential("sigma_not_outlier", lam=1) + else: + sigma_not_outlier = pm.Deterministic( + "sigma_not_outlier", pt.exp(sigma.build(df=df)), dims=[self.obs_dim] + ) + sigma_outlier_offset = pm.Gamma("sigma_outlier_offset", mu=0.2, sigma=0.5) + sigma = pm.Deterministic( + "sigma", + pt.as_tensor([sigma_not_outlier, sigma_not_outlier * (1 + sigma_outlier_offset)]), + dims=["outlier"], + ) + + return sigma + + def register_p_outlier(self, *, df, p_outlier=None, **param_kwargs): + mean_p = param_kwargs.get("mean_p", 0.1) + concentration = param_kwargs.get("concentration", 50) + + with self.model: + if p_outlier is not None: + return pm.Deterministic( + "p_outlier", pt.sigmoid(p_outlier.build(df=df)), dims=[self.obs_dim] + ) + return pm.Beta("p_outlier", mean_p * concentration, (1 - mean_p) * concentration) + + def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: + coords["outlier"] = [False, True] + return MarginalModel(coords=coords) + + +class MixtureLikelihood(BaseMixtureLikelihood): + """ + Class to represent a mixture likelihood function for a GLM component. The mixture is implemented using pm.Mixture, + and does not allow for automatic marginalization of components. + """ + + def __init__( + self, + mu, + sigma, + p_outlier, + target_col: ColumnType, + data: pd.DataFrame, + ): + super().__init__(target_col=target_col, data=data) + + with self.model: + mu = self.register_mu(mu) + sigma = self.register_sigma(sigma) + p_outlier = self.register_p_outlier(p_outlier) + + pm.Mixture( + target_col, + w=[1 - p_outlier, p_outlier], + comp_dists=pm.LogNormal.dist(mu[..., None], sigma=sigma.T), + shape=mu.shape, + observed=self.model[f"{target_col}_observed"], + dims=[self.obs_dim], + ) + + +class UnmarginalizedMixtureLikelihood(BaseMixtureLikelihood): + """ + Class to represent an unmarginalized mixture likelihood function for a GLM component. The mixture is implemented using + a MarginalModel, and allows for automatic marginalization of components. + """ + + def __init__( + self, + mu, + sigma, + p_outlier, + target_col: ColumnType, + data: pd.DataFrame, + ): + super().__init__(target_col=target_col, data=data) + + with self.model: + mu = self.register_mu(mu) + sigma = self.register_sigma(sigma) + p_outlier = self.register_p_outlier(p_outlier) + + is_outlier = pm.Bernoulli( + "is_outlier", + p_outlier, + dims=["cusip"], + # shape=X_pt.shape[0], # Uncomment after https://github.com/pymc-devs/pymc-experimental/pull/304 + ) + + pm.LogNormal( + target_col, + mu=mu, + sigma=pm.math.switch(is_outlier, sigma[1], sigma[0]), + observed=self.model[f"{target_col}_observed"], + shape=mu.shape, + dims=[data.index.name], + ) + + self.model.marginalize(["is_outlier"]) + + def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: + coords["outlier"] = [False, True] + return MarginalModel(coords=coords) diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py new file mode 100644 index 00000000..8e9c27a5 --- /dev/null +++ b/pymc_experimental/model/modular/utilities.py @@ -0,0 +1,276 @@ +import itertools + +from collections.abc import Sequence + +import pandas as pd +import pymc as pm +import pytensor.tensor as pt + +ColumnType = str | Sequence[str] | None + +# Dictionary to define offset distributions for hierarchical models +OFFSET_DIST_FACTORY = { + "zerosum": lambda name, offset_dims: pm.ZeroSumNormal(f"{name}_offset", dims=offset_dims), + "normal": lambda name, offset_dims: pm.Normal(f"{name}_offset", dims=offset_dims), + "laplace": lambda name, offset_dims: pm.Laplace(f"{name}_offset", mu=0, b=1, dims=offset_dims), +} + +# Default kwargs for sigma distributions +SIGMA_DEFAULT_KWARGS = { + "Gamma": {"alpha": 2, "beta": 1}, + "Exponential": {"lam": 1}, + "HalfNormal": {"sigma": 1}, + "HalfCauchy": {"beta": 1}, +} + + +def _get_x_cols( + cols: str | Sequence[str], + model: pm.Model | None = None, +) -> pt.TensorVariable: + model = pm.modelcontext(model) + # Don't upcast a single column to a colum matrix + if isinstance(cols, str): + [cols_idx] = [i for i, col in enumerate(model.coords["feature"]) if col == cols] + else: + cols_idx = [i for i, col in enumerate(model.coords["feature"]) if col is cols] + return model["X_data"][:, cols_idx] + + +def make_level_maps(df: pd.DataFrame, ordered_levels: list[str]): + """ + For each row of data, create a mapping between levels of a arbitrary set of levels defined by `ordered_levels`. + + Consider a set of levels (A, B, C) with members A: [A], B: [B1, B2], C: [C1, C2, C3, C4] arraged in a tree, like: + A + / \ + B1 B2 + / \\ / \ + C1 C2 C3 C4 + + A "deep hierarchy" will have the following priors: + A ~ F(...) + B1, B2 ~ F(A, ...) + C1, C2 ~ F(B1, ...) + C3, C4 ~ F(B2, ...) + + Noting that there could be multiple such trees in a dataset, to create these priors in a memory efficient way we need 2 mappings: B to A, and C to B. These + need to be generated at inference time, and also re-generated for out of sample prediction. + + Parameters + ---------- + df: pd.DataFrame + It's data OK? + + ordered_levels: list[str] + Sequence of level names, ordered from highest to lowest. In the above example, ordered_levels = ['A', 'B', 'C'] + + Returns + ------- + labels: list[pd.Index] + Unique labels generated for each level, sorted alphabetically. Ordering corresponds to the integers in the corresponding mapping, à la pd.factorize + + mappings: list[np.ndarray] + `len(ordered_levels) - 1` list of arrays indexing each previous level to the next level. The i-th array in the list has shape len(df[ordered_levels[i+1]].unique()) + """ + # TODO: Raise an error if there are one-to-many mappings between levels? + if not all([level in df for level in ordered_levels]): + missing = set(ordered_levels) - set(df.columns) + raise ValueError(f'Requested levels were not in provided dataframe: {", ".join(missing)}') + + level_pairs = itertools.pairwise(ordered_levels) + mappings = [] + labels = [] + for pair in level_pairs: + _, level_labels = pd.factorize(df[pair[0]], sort=True) + edges = df[list(pair)].drop_duplicates().set_index(pair[1])[pair[0]].sort_index() + idx = edges.map({k: i for i, k in enumerate(level_labels)}).values + labels.append(level_labels) + mappings.append(idx) + + last_map, last_labels = pd.factorize(df[ordered_levels[-1]], sort=True) + labels.append(last_labels) + mappings.append(last_map) + + return labels, mappings + + +def make_next_level_hierarchy_variable( + name: str, + mu, + sigma_dist: str = "Gamma", + sigma_kwargs: dict | None = None, + mapping=None, + sigma_dims=None, + offset_dims=None, + offset_dist="Normal", + no_pooling=False, +): + if no_pooling: + if mapping is None: + return pm.Deterministic(f"{name}", mu[..., None], dims=offset_dims) + else: + return pm.Deterministic(f"{name}", mu[..., mapping], dims=offset_dims) + + d_sigma = getattr(pm, sigma_dist) + + if sigma_kwargs is None: + if sigma_dist not in SIGMA_DEFAULT_KWARGS: + raise NotImplementedError( + f"No defaults implemented for {sigma_dist}. Pass sigma_kwargs explictly." + ) + sigma_kwargs = SIGMA_DEFAULT_KWARGS[sigma_dist] + + sigma_ = d_sigma(f"{name}_sigma", **sigma_kwargs, dims=sigma_dims) + + offset_dist = offset_dist.lower() + if offset_dist not in OFFSET_DIST_FACTORY: + raise NotImplementedError() + + offset = OFFSET_DIST_FACTORY[offset_dist](name, offset_dims) + + if mapping is None: + return pm.Deterministic( + f"{name}", mu[..., None] + sigma_[..., None] * offset, dims=offset_dims + ) + else: + return pm.Deterministic( + f"{name}", mu[..., mapping] + sigma_[..., mapping] * offset, dims=offset_dims + ) + + +def hierarchical_prior_to_requested_depth( + name: str, + df: pd.DataFrame, + model: pm.Model = None, + dims: list[str] | None = None, + no_pooling: bool = False, + **hierarchy_kwargs, +): + """ + Given a dataframe of categorical data, construct a hierarchical prior that pools data telescopically, moving from + left to right across the columns of the dataframe. + + At its simplest, this function can be used to construct a simple hierarchical prior for a single categorical + variable. Consider the following example: + + .. code-block:: python + + df = pd.DataFrame(['Apple', 'Apple', 'Banana', 'Banana'], columns=['fruit']) + coords = {'fruit': ['Apple', 'Banana']} + with pm.Model(coords=coords) as model: + fruit_effect = hierarchical_prior_to_requested_depth('fruit_effect', df) + + This will construct a simple, non-centered hierarchical intercept corresponding to the 'fruit' feature of the data. + The power of the function comes from its ability to handle multiple categorical variables, and to construct a + hierarchical prior that pools data across multiple levels of a hierarchy. Consider the following example: + + .. code-block:: python + df = pd.DataFrame({'fruit': ['Apple', 'Apple', 'Banana', 'Banana'], + 'color': ['Red', 'Green', 'Yellow', 'Brown']}) + coords = {'fruit': ['Apple', 'Banana'], 'color': ['Red', 'Green', 'Yellow', 'Brown']} + with pm.Model(coords=coords) as model: + fruit_effect = hierarchical_prior_to_requested_depth('fruit_effect', df[['fruit', 'color']]) + + This will construct a two-level hierarchy. The first level will pool all rows of data with the same 'fruit' value, + and the second level will pool color values within each fruit. The structure of the hierarchy will be: + + Apple Banana + / \\ / \ + Red Green Yellow Brown + + That is, estimates for each of "red" and "green" will be centered on the estimate of "apple", and estimates for + "yellow" and "brown" will be centered on the estimate of "banana". + + .. warning:: + Currently, the structure of the data **must** be bijective with respect to the levels of the hierarchy. That is, + each child must map to exactly one parent. In the above example, we could not consider green bananas, for example, + because the "green" level would not uniquely map to "apple". This is a limitation of the current implementation. + + + Parameters + ---------- + name: str + Name of the variable to construct + df: DataFrame + DataFrame of categorical data. Each column represents a level of the hierarchy, with the leftmost column + representing the top level of the hierarchy, with depth increasing to the right. + model: pm.Model, optional + PyMC model to add the variable to. If None, the model on the current context stack is used. + dims: list of str, optional + Additional dimensions to add to the variable. These are treated as batch dimensions, and are added to the + left of the hierarchy dimensions. For example, if dims=['feature'], and df has one column named "country", + the returned variables will have dimensions ['feature', 'country'] + no_pooling: bool, optional + If True, no pooling is applied to the variable. Each level of the hierarchy is treated as independent, with no + informaton shared across level members of a given level. + hierarchy_kwargs: dict + Additional keyword arguments to pass to the underlying PyMC distribution. Options include: + sigma_dist: str + Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" + sigma_kwargs: dict + Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. + Default is {"alpha": 2, "beta": 1} + offset_dist: str, one of ["zerosum", "normal", "laplace"] + Name of the distribution to use for the offset distribution. Default is "zerosum" + + Returns + ------- + pm.Distribution + PyMC distribution representing the hierarchical prior. The shape of the distribution will be + (n_obs, *dims, df.loc[:, -1].nunique()) + """ + + if isinstance(df, pd.Series): + df = df.to_frame() + + model = pm.modelcontext(model) + sigma_dist = hierarchy_kwargs.pop("sigma_dist", "Gamma") + sigma_kwargs = hierarchy_kwargs.pop("sigma_kwargs", {"alpha": 2, "beta": 1}) + offset_dist = hierarchy_kwargs.pop("offset_dist", "zerosum") + + levels = [None, *df.columns.tolist()] + n_levels = len(levels) - 1 + idx_maps = None + if n_levels > 1: + labels, idx_maps = make_level_maps(df, levels[1:]) + + if idx_maps: + idx_maps = [None, *idx_maps] + else: + idx_maps = [None] + + for level_dim in levels[1:]: + _, labels = pd.factorize(df[level_dim], sort=True) + if level_dim not in model.coords: + model.add_coord(level_dim, labels) + + # Danger zone, this assumes we factorized the same way here and in X_data + deepest_map = _get_x_cols(df.columns[-1]).astype("int") + + with model: + beta = pm.Normal(f"{name}_effect", 0, 1, dims=dims) + for i, (level, last_level) in enumerate(zip(levels[1:], levels[:-1])): + if i == 0: + sigma_dims = dims + else: + sigma_dims = [*dims, last_level] if dims is not None else [last_level] + offset_dims = [*dims, level] if dims is not None else [level] + + # TODO: Need a better way to handle different priors at each level. + if "beta" in sigma_kwargs: + sigma_kwargs["beta"] = sigma_kwargs["beta"] ** (i + 1) + + beta = make_next_level_hierarchy_variable( + f"{name}_{level}_effect", + mu=beta, + sigma_dist=sigma_dist, + sigma_kwargs=sigma_kwargs, + mapping=idx_maps[i], + sigma_dims=sigma_dims, + offset_dims=offset_dims, + offset_dist=offset_dist, + no_pooling=no_pooling, + ) + + return beta[..., deepest_map] From 404550de3ce042f3dc97a48169ab99185ebc46d5 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Tue, 10 Dec 2024 06:10:12 -0600 Subject: [PATCH 2/9] Remove curve component (not relevant in general) --- pymc_experimental/model/modular/components.py | 242 ------------------ 1 file changed, 242 deletions(-) diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index 16315285..d53c7a93 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -12,17 +12,6 @@ POOLING_TYPES = Literal["none", "complete", "partial"] valid_pooling = get_args(POOLING_TYPES) -CURVE_TYPES = Literal["log", "abc", "ns", "nss", "box-cox"] -valid_curves = get_args(CURVE_TYPES) - - -FEATURE_DICT = { - "log": ["slope"], - "box-cox": ["lambda", "slope", "intercept"], - "nss": ["tau", "beta0", "beta1", "beta2"], - "abc": ["a", "b", "c"], -} - def _validate_pooling_params(pooling_columns: ColumnType, pooling: POOLING_TYPES): """ @@ -191,237 +180,6 @@ def build(self, model=None): return intercept -def build_curve( - time_pt: pt.TensorVariable, - beta: pt.TensorVariable, - curve_type: Literal["log", "abc", "ns", "nss", "box-cox"], -): - """ - Build a curve based on the time data and parameters beta. - - In this context, a "curve" is a deterministic function that maps time to a value. The curve should (in general) be - strictly increasing with time (df(t)/dt > 0), and should (in general) exhibit diminishing marginal growth with time - (d^2f(t)/dt^2 < 0). These properties are not strictly necessary; some curve functions (such as nss) allow for - local reversals. - - Parameters - ---------- - time_pt: TensorVariable - A pytensor variable representing the time data to build the curve from. - beta: TensorVariable - A pytensor variable representing the parameters of the curve. The number of parameters and their meaning depend - on the curve_type. - - .. warning:: - Currently no checks are in place to ensure that the number of parameters in beta matches the expected number - for the curve_type. - - curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] - Type of curve to build. Options are: - - - "log": - A simple log-linear curve. The curve is defined as: - - .. math:: - - \beta \\log(t) - - - "abc": - A curve parameterized by "a", "b", and "c", such that the minimum value of the curve is "a", the - maximum value is "a + b", and the inflection point is "a + b / c". "C" thus controls the speed of change - from the minimum to the maximum value. The curve is defined as: - - .. math:: - - \frac{a + bc t}{1 + ct} - - - "ns": - The Nelson-Siegel yield curve model. The curve is parameterized by three parameters: :math:`\tau`, - :math:`\beta_1`, and :math:`\beta_2`. :math:`\tau` is the decay rate of the exponential term, and - :math:`\beta_1` and :math:`\beta_2` control the slope and curvature of the curve. The curve is defined as: - - .. math:: - - \begin{align} - x_t &= \beta_1 \\phi(t) + \beta_2 \\left (\\phi(t) - \\exp(-t/\tau) \right ) \\ - \\phi(t) &= \frac{1 - \\exp(-t/\tau)}{t/\tau} - \\end{align} - - - "nss": - The Nelson-Siegel-Svensson yield curve model. The curve is parameterized by four parameters: - :math:`\tau_1`, :math:`\tau_2`, :math:`\beta_1`, and :math:`\beta_2`. :math:`\beta_3` - - Where :math:`\tau_1` and :math:`\tau_2` are the decay rates of the two exponential terms, :math:`\beta_1` - controls the slope of the curve, and :math:`\beta_2` and :math:`\beta_3` control the curvature of the curve. - To ensure that short-term rates are strictly postitive, one typically restrices :math:`\beta_1 + \beta_2 > 0`. - - The curve is defined as: - - .. math:: - \begin{align} - x_t & = \beta_1 \\phi_1(t) + \beta_2 \\left (\\phi_1(t) - \\exp(-t/\tau_1) \right) + \beta_3 \\left (\\phi_2(t) - \\exp(-t/\tau_2) \right) \\ - \\phi_1(t) &= \frac{1 - \\exp(-t/\tau_1)}{t/\tau_1} \\ - \\phi_2(t) &= \frac{1 - \\exp(-t/\tau_2)}{t/\tau_2} - \\end{align} - - Note that this definition omits the constant term that is typically included in the Nelson-Siegel-Svensson; - you are assumed to have already accounted for this with another component in the model. - - - "box-cox": - A curve that applies a box-cox transformation to the time data. The curve is parameterized by two - parameters: :math:`\\lambda` and :math:`\beta`, where :math:`\\lambda` is the box-cox parameter that - interpolates between the log and linear transformations, and :math:`\beta` is the slope of the curve. - - The curve is defined as: - - .. math:: - - \beta \\left ( \frac{t^{\\lambda} - 1}{\\lambda} \right ) - - Returns - ------- - TensorVariable - A pytensor variable representing the curve. - """ - if curve_type == "box-cox": - lam = beta[0] + 1e-12 - time_scaled = (time_pt**lam - 1) / lam - curve = beta[1] * time_scaled - - elif curve_type == "log": - time_scaled = pt.log(time_pt) - curve = beta[0] * time_scaled - - elif curve_type == "ns": - tau = pt.exp(beta[0]) - t_over_tau = time_pt / tau - time_scaled = (1 - pt.exp(-t_over_tau)) / t_over_tau - curve = beta[1] * time_scaled + beta[2] * (time_scaled - pt.exp(-t_over_tau)) - - elif curve_type == "nss": - tau = pt.exp(beta[:2]) - beta = beta[2:] - t_over_tau_1 = time_pt / tau[0] - t_over_tau_2 = time_pt / tau[1] - time_scaled_1 = (1 - pt.exp(t_over_tau_1)) / t_over_tau_1 - time_scaled_2 = (1 - pt.exp(t_over_tau_2)) / t_over_tau_2 - curve = ( - beta[0] * time_scaled_1 - + beta[1] * (time_scaled_1 - pt.exp(-t_over_tau_1)) - + beta[2] * (time_scaled_2 - pt.exp(-t_over_tau_2)) - ) - - elif curve_type == "abc": - curve = (beta[0] + beta[1] * beta[2] * time_pt) / (1 + beta[2] * time_pt) - - else: - raise ValueError(f"Unknown curve type: {curve_type}") - - return curve - - -class Curve(GLMModel): - def __init__( - self, - name: str, - t: pd.Series | pd.DataFrame, - prior: str = "Normal", - index_data: pd.Series | pd.DataFrame | None = None, - pooling: POOLING_TYPES = "complete", - curve_type: CURVE_TYPES = "log", - prior_params: dict | None = None, - hierarchical_params: dict | None = None, - ): - """ - Class to represent a curve in a GLM model. - - A curve is a deterministic function that transforms time data via a non-linear function. Currently, the following - curve types are supported: - - "log": A simple log-linear curve. - - "abc": A curve defined by a minimum value (a), maximum value (b), and inflection point ((a + b) / c). - - "ns": The Nelson-Siegel yield curve model. - - "nss": The Nelson-Siegel-Svensson yield curve model. - - "box-cox": A curve that applies a box-cox transformation to the time data. - - Parameters - ---------- - name: str, optional - Name of the intercept term. If None, a default name is generated based on the index_data. - t: Series - Time data used to build the curve. If Series, must have a name attribute. If dataframe, must have exactly - one column. - index_data: Series or DataFrame, optional - Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as - levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, - and depth increasing to the right. - - The index of the index_data must match the index of the observed data. - prior: str, optional - Name of the PyMC distribution to use for the intercept term. Default is "Normal". - pooling: str, one of ["none", "complete", "partial"], default "complete" - Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the - index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated - as coming from the same group. If "partial", a hierarchical prior is constructed that shares information - across groups in the index_data. - curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] - Type of curve to build. For details, see the build_curve function. - prior_params: dict, optional - Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. - hierarchical_params: dict, optional - Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. - Options include: - sigma_dist: str - Name of the distribution to use for the standard deviation of the hierarchy. Default is "Gamma" - sigma_kwargs: dict - Additional keyword arguments to pass to the sigma distribution specified by the sigma_dist argument. - Default is {"alpha": 2, "beta": 1} - offset_dist: str, one of ["zerosum", "normal", "laplace"] - Name of the distribution to use for the offset distribution. Default is "zerosum" - """ - - _validate_pooling_params(index_data, pooling) - - self.name = name - self.t = t if isinstance(t, pd.Series) else t.iloc[:, 0] - self.curve_type = curve_type - - self.index_data = index_data - self.pooling = pooling - - self.prior = prior - self.prior_params = prior_params if prior_params is not None else {} - self.hierarchical_params = hierarchical_params if hierarchical_params is not None else {} - - super().__init__() - - def build(self, model=None): - model = pm.modelcontext(model) - obs_dim = self.t.index.name - feature_dim = f"{self.name}_features" - if feature_dim not in model.coords: - model.add_coord(feature_dim, FEATURE_DICT[self.curve_type]) - - with model: - t_pt = pm.Data("t", self.t.values, dims=[obs_dim]) - if self.pooling == "complete": - beta = getattr(pm, self.prior)( - f"{self.name}_beta", **self.prior_params, dims=[feature_dim] - ) - curve = build_curve(t_pt, beta, self.curve_type) - return pm.Deterministic(f"{self.name}", curve, dims=[obs_dim]) - - beta = hierarchical_prior_to_requested_depth( - self.name, - self.index_data, - model=model, - dims=[feature_dim], - no_pooling=self.pooling == "none", - ) - - curve = build_curve(t_pt, beta, self.curve_type) - return pm.Deterministic(f"{self.name}", curve, dims=[obs_dim]) - - class Regression(GLMModel): def __init__( self, From 7b3cdcf328252d7cd3f8e98e868edc76407a3a36 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Tue, 10 Dec 2024 06:34:03 -0600 Subject: [PATCH 3/9] Update intercept docstring --- pymc_experimental/model/modular/components.py | 30 +++++++++---------- pymc_experimental/model/modular/likelihood.py | 15 +++++----- pymc_experimental/model/modular/utilities.py | 4 +++ 3 files changed, 25 insertions(+), 24 deletions(-) diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index d53c7a93..a412f3e0 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -6,7 +6,7 @@ import pymc as pm import pytensor.tensor as pt -from model.modular.utilities import ColumnType, hierarchical_prior_to_requested_depth +from model.modular.utilities import ColumnType, get_X_data, hierarchical_prior_to_requested_depth from patsy import dmatrix POOLING_TYPES = Literal["none", "complete", "partial"] @@ -105,7 +105,6 @@ def __init__( prior_params: dict | None = None, ): """ - TODO: Update signature docs Class to represent an intercept term in a GLM model. By intercept, it is meant any constant term in the model that is not a function of any input data. This can be @@ -116,21 +115,15 @@ def __init__( ---------- name: str, optional Name of the intercept term. If None, a default name is generated based on the index_data. - index_data: Series or DataFrame, optional - Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as - levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, - and depth increasing to the right. - - The index of the index_data must match the index of the observed data. - prior: str, optional - Name of the PyMC distribution to use for the intercept term. Default is "Normal". + pooling_cols: str or list of str, optional + Columns of the independent data to use as labels for pooling. These columns will be treated as categorical. + If None, no pooling is applied. If a list is provided, a "telescoping" hierarchy is constructed from left + to right, with the mean of each subsequent level centered on the mean of the previous level. pooling: str, one of ["none", "complete", "partial"], default "complete" Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated as coming from the same group. If "partial", a hierarchical prior is constructed that shares information across groups in the index_data. - prior_params: dict, optional - Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. hierarchical_params: dict, optional Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. Options include: @@ -141,6 +134,11 @@ def __init__( Default is {"alpha": 2, "beta": 1} offset_dist: str, one of ["zerosum", "normal", "laplace"] Name of the distribution to use for the offset distribution. Default is "zerosum" + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". + prior_params: dict, optional + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + """ _validate_pooling_params(pooling_cols, pooling) @@ -158,25 +156,25 @@ def __init__( data_name = ", ".join(pooling_cols) self.name = name or f"Constant(pooling_cols={data_name})" + super().__init__() - def build(self, model=None): + def build(self, model: pm.Model | None = None): model = pm.modelcontext(model) with model: if self.pooling == "complete": intercept = getattr(pm, self.prior)(f"{self.name}", **self.prior_params) return intercept - [i for i, col in enumerate(model.coords["feature"]) if col in self.pooling_cols] - intercept = hierarchical_prior_to_requested_depth( self.name, - model.X_df[self.pooling_cols], # TODO: Reconsider this + df=get_X_data(model)[self.pooling_cols], model=model, dims=None, no_pooling=self.pooling == "none", **self.hierarchical_params, ) + return intercept diff --git a/pymc_experimental/model/modular/likelihood.py b/pymc_experimental/model/modular/likelihood.py index 32b4f432..2d9813fe 100644 --- a/pymc_experimental/model/modular/likelihood.py +++ b/pymc_experimental/model/modular/likelihood.py @@ -43,18 +43,18 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): # TODO: Reconsider this (two sources of nearly the same info not good) X_df = data.drop(columns=[target_col]) - X_data = X_df.copy() + self.column_labels = {} - for col, dtype in X_data.dtypes.to_dict().items(): + for col, dtype in X_df.dtypes.to_dict().items(): if dtype.name.startswith("float"): pass elif dtype.name == "object": # TODO: We definitely need to save these if we want to factorize predict data - col_array, labels = pd.factorize(X_data[col], sort=True) - X_data[col] = col_array.astype("float64") + col_array, labels = pd.factorize(X_df[col], sort=True) + X_df[col] = col_array.astype("float64") self.column_labels[col] = {label: i for i, label in enumerate(labels.values)} elif dtype.name.startswith("int"): - X_data[col] = X_data[col].astype("float64") + X_df[col] = X_df[col].astype("float64") else: raise NotImplementedError( f"Haven't decided how to handle the following type: {dtype.name}" @@ -63,14 +63,13 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): self.obs_dim = data.index.name coords = { self.obs_dim: data.index.values, - "feature": list(X_data.columns), + "feature": list(X_df.columns), } with self._get_model_class(coords) as self.model: - self.model.X_df = X_df # FIXME: Definitely not a solution pm.Data(f"{target_col}_observed", data[target_col], dims=self.obs_dim) pm.Data( "X_data", - X_data, + X_df, dims=(self.obs_dim, "feature"), shape=(None, len(coords["feature"])), ) diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index 8e9c27a5..b3e8dee9 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -37,6 +37,10 @@ def _get_x_cols( return model["X_data"][:, cols_idx] +def get_X_data(model, data_name="X_data"): + return model[data_name] + + def make_level_maps(df: pd.DataFrame, ordered_levels: list[str]): """ For each row of data, create a mapping between levels of a arbitrary set of levels defined by `ordered_levels`. From b243326597fe63f6cba8de9d883a355dac208963 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Wed, 11 Dec 2024 21:26:17 -0500 Subject: [PATCH 4/9] Add tests for utilities --- pymc_experimental/model/modular/components.py | 162 ++++++++------- pymc_experimental/model/modular/likelihood.py | 28 ++- pymc_experimental/model/modular/utilities.py | 154 +++++++------- tests/model/modular/test_utilities.py | 193 ++++++++++++++++++ 4 files changed, 386 insertions(+), 151 deletions(-) create mode 100644 tests/model/modular/test_utilities.py diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index a412f3e0..9e6620ba 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -1,27 +1,29 @@ from abc import ABC, abstractmethod -from collections.abc import Sequence from typing import Literal, get_args import pandas as pd import pymc as pm -import pytensor.tensor as pt -from model.modular.utilities import ColumnType, get_X_data, hierarchical_prior_to_requested_depth +from model.modular.utilities import ( + ColumnType, + get_X_data, + hierarchical_prior_to_requested_depth, + select_data_columns, +) from patsy import dmatrix -POOLING_TYPES = Literal["none", "complete", "partial"] -valid_pooling = get_args(POOLING_TYPES) +PoolingType = Literal["none", "complete", "partial", None] +valid_pooling = get_args(PoolingType) -def _validate_pooling_params(pooling_columns: ColumnType, pooling: POOLING_TYPES): +def _validate_pooling_params(pooling_columns: ColumnType, pooling: PoolingType): """ Helper function to validate inputs to a GLM component. Parameters ---------- - index_data: Series or DataFrame - Index data used to build hierarchical priors - + pooling_columns: str or list of str + Data columns used to construct a hierarchical prior pooling: str Type of pooling to use in the component @@ -38,25 +40,13 @@ def _validate_pooling_params(pooling_columns: ColumnType, pooling: POOLING_TYPES ) -def _get_x_cols( - cols: str | Sequence[str], - model: pm.Model | None = None, -) -> pt.TensorVariable: - model = pm.modelcontext(model) - # Don't upcast a single column to a colum matrix - if isinstance(cols, str): - [cols_idx] = [i for i, col in enumerate(model.coords["feature"]) if col == cols] - else: - cols_idx = [i for i, col in enumerate(model.coords["feature"]) if col is cols] - return model["X_data"][:, cols_idx] - - class GLMModel(ABC): """Base class for GLM components. Subclasses should implement the build method to construct the component.""" - def __init__(self): + def __init__(self, name): self.model = None self.compiled = False + self.name = name @abstractmethod def build(self, model=None): @@ -68,6 +58,9 @@ def __add__(self, other): def __mul__(self, other): return MultiplicativeGLMComponent(self, other) + def __str__(self): + return self.name + class AdditiveGLMComponent(GLMModel): """Class to represent an additive combination of GLM components""" @@ -99,7 +92,7 @@ def __init__( name: str | None = None, *, pooling_cols: ColumnType = None, - pooling: POOLING_TYPES = "complete", + pooling: PoolingType = "complete", hierarchical_params: dict | None = None, prior: str = "Normal", prior_params: dict | None = None, @@ -154,16 +147,15 @@ def __init__( elif isinstance(pooling_cols, str): pooling_cols = [pooling_cols] - data_name = ", ".join(pooling_cols) - self.name = name or f"Constant(pooling_cols={data_name})" + name = name or f"Intercept(pooling_cols={pooling_cols})" - super().__init__() + super().__init__(name=name) def build(self, model: pm.Model | None = None): model = pm.modelcontext(model) with model: if self.pooling == "complete": - intercept = getattr(pm, self.prior)(f"{self.name}", **self.prior_params) + intercept = getattr(pm, self.prior.title())(f"{self.name}", **self.prior_params) return intercept intercept = hierarchical_prior_to_requested_depth( @@ -181,11 +173,13 @@ def build(self, model: pm.Model | None = None): class Regression(GLMModel): def __init__( self, - name: str, - X: pd.DataFrame, + name: str | None = None, + *, + feature_columns: ColumnType | None = None, prior: str = "Normal", - index_data: pd.Series = None, - pooling: POOLING_TYPES = "complete", + pooling: PoolingType = "complete", + pooling_columns: ColumnType | None = None, + hierarchical_params: dict | None = None, **prior_params, ): """ @@ -199,15 +193,8 @@ def __init__( ---------- name: str, optional Name of the intercept term. If None, a default name is generated based on the index_data. - X: DataFrame - Exogenous data used to build the regression component. Each column of the DataFrame represents a feature - used in the regression. Index of the DataFrame should match the index of the observed data. - index_data: Series or DataFrame, optional - Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as - levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, - and depth increasing to the right. - - The index of the index_data must match the index of the observed data. + feature_columns: str or list of str + Columns of the independent data to use in the regression. prior: str, optional Name of the PyMC distribution to use for the intercept term. Default is "Normal". pooling: str, one of ["none", "complete", "partial"], default "complete" @@ -215,10 +202,10 @@ def __init__( index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated as coming from the same group. If "partial", a hierarchical prior is constructed that shares information across groups in the index_data. - curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] - Type of curve to build. For details, see the build_curve function. - prior_params: dict, optional - Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. + pooling_columns: str or list of str, optional + Columns of the independent data to use as labels for pooling. These columns will be treated as categorical. + If None, no pooling is applied. If a list is provided, a "telescoping" hierarchy is constructed from left + to right, with the mean of each subsequent level centered on the mean of the previous level. hierarchical_params: dict, optional Additional keyword arguments to configure priors in the hierarchical_prior_to_requested_depth function. Options include: @@ -229,34 +216,37 @@ def __init__( Default is {"alpha": 2, "beta": 1} offset_dist: str, one of ["zerosum", "normal", "laplace"] Name of the distribution to use for the offset distribution. Default is "zerosum" + prior_params: + Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. """ - _validate_pooling_params(index_data, pooling) + _validate_pooling_params(pooling_columns, pooling) - self.name = name - self.X = X - self.index_data = index_data + self.feature_columns = feature_columns self.pooling = pooling + self.pooling_columns = pooling_columns self.prior = prior self.prior_params = prior_params - super().__init__() + name = name if name else f"Regression({feature_columns})" + + super().__init__(name=name) def build(self, model=None): model = pm.modelcontext(model) feature_dim = f"{self.name}_features" - obs_dim = self.X.index.name if feature_dim not in model.coords: model.add_coord(feature_dim, self.X.columns) with model: - X_pt = pm.Data(f"{self.name}_data", self.X.values, dims=[obs_dim, feature_dim]) + X = select_data_columns(get_X_data(model), self.feature_columns) + if self.pooling == "complete": beta = getattr(pm, self.prior)( f"{self.name}", **self.prior_params, dims=[feature_dim] ) - return X_pt @ beta + return X @ beta beta = hierarchical_prior_to_requested_depth( self.name, @@ -266,7 +256,7 @@ def build(self, model=None): no_pooling=self.pooling == "none", ) - regression_effect = (X_pt * beta.T).sum(axis=-1) + regression_effect = (X * beta.T).sum(axis=-1) return regression_effect @@ -274,11 +264,12 @@ class Spline(Regression): def __init__( self, name: str, + *, + feature_column: str | None = None, n_knots: int = 10, - spline_data: pd.Series | pd.DataFrame | None = None, prior: str = "Normal", index_data: pd.Series | None = None, - pooling: POOLING_TYPES = "complete", + pooling: PoolingType = "complete", **prior_params, ): """ @@ -297,10 +288,8 @@ def __init__( Name of the intercept term. If None, a default name is generated based on the index_data. n_knots: int, default 10 Number of knots to use in the spline basis. - spline_data: Series or DataFrame - Exogenous data to be interpolated using basis splines. If Series, must have a name attribute. If dataframe, - must have exactly one column. In either case, the index of the data should match the index of the observed - data. + feature_column: str + Column of the independent data to use in the spline. index_data: Series or DataFrame, optional Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, @@ -330,17 +319,46 @@ def __init__( Name of the distribution to use for the offset distribution. Default is "zerosum" """ _validate_pooling_params(index_data, pooling) + self.name = name if name else f"Spline({feature_column})" + self.feature_column = feature_column + self.n_knots = n_knots + self.prior = prior + self.prior_params = prior_params - spline_features = dmatrix( - f"bs(maturity_years, df={n_knots}, degree=3) - 1", - {"maturity_years": spline_data}, - ) - X = pd.DataFrame( - spline_features, - index=spline_data.index, - columns=[f"Spline_{i}" for i in range(n_knots)], - ) + super().__init__(name=name) - super().__init__( - name=name, X=X, prior=prior, index_data=index_data, pooling=pooling, **prior_params - ) + def build(self, model: pm.Model | None = None): + model = pm.modelcontext(model) + model.add_coord(f"{self.name}_spline", range(self.n_knots)) + + with model: + spline_data = { + self.feature_column: select_data_columns( + get_X_data(model).get_value(), self.feature_column + ) + } + + X_spline = dmatrix( + f"bs({self.feature_column}, df={self.n_knots}, degree=3) - 1", + data=spline_data, + return_type="dataframe", + ) + + if self.pooling == "complete": + beta = getattr(pm, self.prior)( + f"{self.name}", **self.prior_params, dims=f"{self.feature_column}_spline" + ) + return X_spline @ beta + + elif self.pooling_columns is not None: + X = select_data_columns(self.pooling_columns, model) + beta = hierarchical_prior_to_requested_depth( + name=self.name, + X=X, + model=model, + dims=[f"{self.feature_column}_spline"], + no_pooling=self.pooling == "none", + ) + + spline_effect = (X_spline * beta.T).sum(axis=-1) + return spline_effect diff --git a/pymc_experimental/model/modular/likelihood.py b/pymc_experimental/model/modular/likelihood.py index 2d9813fe..8d1b34eb 100644 --- a/pymc_experimental/model/modular/likelihood.py +++ b/pymc_experimental/model/modular/likelihood.py @@ -3,6 +3,7 @@ from typing import Literal, get_args import arviz as az +import numpy as np import pandas as pd import pymc as pm import pytensor.tensor as pt @@ -44,7 +45,11 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): # TODO: Reconsider this (two sources of nearly the same info not good) X_df = data.drop(columns=[target_col]) - self.column_labels = {} + self.obs_dim = data.index.name + self.coords = { + self.obs_dim: data.index.values, + } + for col, dtype in X_df.dtypes.to_dict().items(): if dtype.name.startswith("float"): pass @@ -52,26 +57,31 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): # TODO: We definitely need to save these if we want to factorize predict data col_array, labels = pd.factorize(X_df[col], sort=True) X_df[col] = col_array.astype("float64") - self.column_labels[col] = {label: i for i, label in enumerate(labels.values)} + self.coords[col] = labels elif dtype.name.startswith("int"): + _data = X_df[col].copy() X_df[col] = X_df[col].astype("float64") + assert np.all( + _data == X_df[col].astype("int") + ), "Information was lost in conversion to float" + else: raise NotImplementedError( f"Haven't decided how to handle the following type: {dtype.name}" ) - self.obs_dim = data.index.name - coords = { - self.obs_dim: data.index.values, - "feature": list(X_df.columns), - } - with self._get_model_class(coords) as self.model: + numeric_cols = [ + col for col, dtype in X_df.dtypes.to_dict().items() if dtype.name.startswith("float") + ] + self.coords["feature"] = numeric_cols + + with self._get_model_class(self.coords) as self.model: pm.Data(f"{target_col}_observed", data[target_col], dims=self.obs_dim) pm.Data( "X_data", X_df, dims=(self.obs_dim, "feature"), - shape=(None, len(coords["feature"])), + shape=(None, len(self.coords["feature"])), ) self._predict_fn = None # We are caching function for faster predictions diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index b3e8dee9..e65a9b2d 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -2,11 +2,12 @@ from collections.abc import Sequence -import pandas as pd import pymc as pm import pytensor.tensor as pt -ColumnType = str | Sequence[str] | None +from pytensor.compile import SharedVariable + +ColumnType = str | list[str] # Dictionary to define offset distributions for hierarchical models OFFSET_DIST_FACTORY = { @@ -24,33 +25,60 @@ } -def _get_x_cols( - cols: str | Sequence[str], +def select_data_columns( + cols: str | Sequence[str] | None, model: pm.Model | None = None, -) -> pt.TensorVariable: + data_name: str = "X_data", +) -> pt.TensorVariable | None: + """ + Create a tensor variable representing a subset of independent data columns. + + Parameters + ---------- + cols: str or list of str + Column names to select from the independent data + model: Model, optional + PyMC model object. If None, the model is taken from the context. + + Returns + ------- + X: TensorVariable + A tensor variable representing the selected columns of the independent data + """ model = pm.modelcontext(model) - # Don't upcast a single column to a colum matrix + if isinstance(cols, None): + return + if isinstance(cols, str): - [cols_idx] = [i for i, col in enumerate(model.coords["feature"]) if col == cols] - else: - cols_idx = [i for i, col in enumerate(model.coords["feature"]) if col is cols] - return model["X_data"][:, cols_idx] + cols = [cols] + + missing_cols = [col for col in cols if col not in model.coords["feature"]] + if missing_cols: + raise ValueError(f"Columns {missing_cols} not found in the model") + cols_idx = [model.coords["feature"].index(col) for col in cols] -def get_X_data(model, data_name="X_data"): + # Single columns are returned as 1d arrays + if len(cols_idx) == 1: + cols_idx = cols_idx[0] + + return get_X_data(model, data_name=data_name)[:, cols_idx] + + +def get_X_data(model, data_name="X_data") -> SharedVariable: return model[data_name] -def make_level_maps(df: pd.DataFrame, ordered_levels: list[str]): - """ +def make_level_maps(X: SharedVariable, coords: dict[str, tuple | None], ordered_levels: list[str]): + r""" For each row of data, create a mapping between levels of a arbitrary set of levels defined by `ordered_levels`. Consider a set of levels (A, B, C) with members A: [A], B: [B1, B2], C: [C1, C2, C3, C4] arraged in a tree, like: A - / \ - B1 B2 - / \\ / \ - C1 C2 C3 C4 + / \ + B1 B2 + / \ / \ + C1 C2 C3 C4 A "deep hierarchy" will have the following priors: A ~ F(...) @@ -63,40 +91,36 @@ def make_level_maps(df: pd.DataFrame, ordered_levels: list[str]): Parameters ---------- - df: pd.DataFrame + X: pt.TensorVariable It's data OK? + coords: dict[str, list[str]] + Dictionary of levels and their members. In the above example, + ``coords = {'A': ['A'], 'B': ['B1', 'B2'], 'C': ['C1', 'C2', 'C3', 'C4']}`` + ordered_levels: list[str] - Sequence of level names, ordered from highest to lowest. In the above example, ordered_levels = ['A', 'B', 'C'] + Sequence of level names, ordered from highest to lowest. In the above example, + ordered_levels = ['A', 'B', 'C'] Returns ------- - labels: list[pd.Index] - Unique labels generated for each level, sorted alphabetically. Ordering corresponds to the integers in the corresponding mapping, à la pd.factorize - - mappings: list[np.ndarray] - `len(ordered_levels) - 1` list of arrays indexing each previous level to the next level. The i-th array in the list has shape len(df[ordered_levels[i+1]].unique()) + mappings: list[pt.TensorVariable] + `len(ordered_levels) - 1` list of arrays indexing each previous level to the next level. + The i-th array in the list has shape len(df[ordered_levels[i+1]].unique()) """ - # TODO: Raise an error if there are one-to-many mappings between levels? - if not all([level in df for level in ordered_levels]): - missing = set(ordered_levels) - set(df.columns) - raise ValueError(f'Requested levels were not in provided dataframe: {", ".join(missing)}') - - level_pairs = itertools.pairwise(ordered_levels) - mappings = [] - labels = [] - for pair in level_pairs: - _, level_labels = pd.factorize(df[pair[0]], sort=True) - edges = df[list(pair)].drop_duplicates().set_index(pair[1])[pair[0]].sort_index() - idx = edges.map({k: i for i, k in enumerate(level_labels)}).values - labels.append(level_labels) - mappings.append(idx) - last_map, last_labels = pd.factorize(df[ordered_levels[-1]], sort=True) - labels.append(last_labels) - mappings.append(last_map) + level_idxs = [coords["feature"].index(level) for level in ordered_levels] + level_pairs = itertools.pairwise(level_idxs) + + mappings = [None] - return labels, mappings + for pair in level_pairs: + edges = pt.unique(X[:, list(pair)], axis=0) + sorted_idx = pt.argsort(edges[:, 1]) + mappings.append(edges[sorted_idx, 0].astype(int)) + + mappings.append(X[:, level_idxs[-1]].astype(int)) + return mappings def make_next_level_hierarchy_variable( @@ -145,12 +169,13 @@ def make_next_level_hierarchy_variable( def hierarchical_prior_to_requested_depth( name: str, - df: pd.DataFrame, + X: SharedVariable, + pooling_columns: ColumnType = None, model: pm.Model = None, dims: list[str] | None = None, no_pooling: bool = False, **hierarchy_kwargs, -): +) -> pt.TensorVariable: """ Given a dataframe of categorical data, construct a hierarchical prior that pools data telescopically, moving from left to right across the columns of the dataframe. @@ -179,10 +204,13 @@ def hierarchical_prior_to_requested_depth( This will construct a two-level hierarchy. The first level will pool all rows of data with the same 'fruit' value, and the second level will pool color values within each fruit. The structure of the hierarchy will be: + .. code-block:: + Apple Banana - / \\ / \ + / \\ / \ Red Green Yellow Brown + That is, estimates for each of "red" and "green" will be centered on the estimate of "apple", and estimates for "yellow" and "brown" will be centered on the estimate of "banana". @@ -196,9 +224,12 @@ def hierarchical_prior_to_requested_depth( ---------- name: str Name of the variable to construct - df: DataFrame - DataFrame of categorical data. Each column represents a level of the hierarchy, with the leftmost column - representing the top level of the hierarchy, with depth increasing to the right. + X: SharedVariable + Feature data associated with the GLM model. Encoded categorical features used to form the hierarchical prior + are expected to be columns in this data. + pooling_columns: str or list of str + Columns of the dataframe to use as the index of the hierarchy. If a list is provided, the hierarchy will be + constructed from left to right across the columns. model: pm.Model, optional PyMC model to add the variable to. If None, the model on the current context stack is used. dims: list of str, optional @@ -225,36 +256,19 @@ def hierarchical_prior_to_requested_depth( (n_obs, *dims, df.loc[:, -1].nunique()) """ - if isinstance(df, pd.Series): - df = df.to_frame() - model = pm.modelcontext(model) + coords = model.coords + sigma_dist = hierarchy_kwargs.pop("sigma_dist", "Gamma") sigma_kwargs = hierarchy_kwargs.pop("sigma_kwargs", {"alpha": 2, "beta": 1}) offset_dist = hierarchy_kwargs.pop("offset_dist", "zerosum") - levels = [None, *df.columns.tolist()] - n_levels = len(levels) - 1 - idx_maps = None - if n_levels > 1: - labels, idx_maps = make_level_maps(df, levels[1:]) - - if idx_maps: - idx_maps = [None, *idx_maps] - else: - idx_maps = [None] - - for level_dim in levels[1:]: - _, labels = pd.factorize(df[level_dim], sort=True) - if level_dim not in model.coords: - model.add_coord(level_dim, labels) - - # Danger zone, this assumes we factorized the same way here and in X_data - deepest_map = _get_x_cols(df.columns[-1]).astype("int") + idx_maps = make_level_maps(X, coords, pooling_columns) + deepest_map = idx_maps[-1] with model: beta = pm.Normal(f"{name}_effect", 0, 1, dims=dims) - for i, (level, last_level) in enumerate(zip(levels[1:], levels[:-1])): + for i, (last_level, level) in enumerate(itertools.pairwise([None, *pooling_columns])): if i == 0: sigma_dims = dims else: diff --git a/tests/model/modular/test_utilities.py b/tests/model/modular/test_utilities.py new file mode 100644 index 00000000..af4334eb --- /dev/null +++ b/tests/model/modular/test_utilities.py @@ -0,0 +1,193 @@ +import numpy as np +import pandas as pd +import pymc as pm +import pytensor +import pytest + +from numpy.testing import assert_allclose + +from pymc_experimental.model.modular.utilities import ( + hierarchical_prior_to_requested_depth, + make_level_maps, + make_next_level_hierarchy_variable, + select_data_columns, +) + + +@pytest.fixture(scope="session") +def rng(): + return np.random.default_rng() + + +@pytest.fixture(scope="session") +def df(rng): + N = 1000 + + level_0_labels = ["Beverage", "Snack"] + level_1_labels = { + "Beverage": ["Soft Drinks", "Milk", "Smoothies", "Sports Drinks", "Alcoholic Beverages"], + "Snack": ["Jerky", "Pretzels", "Nuts", "Tea"], + } + level_2_labels = { + "Soft Drinks": ["Lemonade", "Cola", "Root Beer", "Ginger Ale"], + "Milk": ["Oat Milk", "Cow Milk", "Soy Milk"], + "Smoothies": ["Green Smoothies", "Berry Smoothies"], + "Sports Drinks": ["Gatorade", "Powerade"], + "Alcoholic Beverages": ["Beer", "Wine", "Spirits"], + "Jerky": ["Vegan Jerky", "Beef Jerky"], + "Pretzels": ["Salted Pretzels", "Unsalted Pretzels"], + "Nuts": ["Peanuts", "Almonds", "Cashews", "Pistachios", "Walnuts"], + "Tea": ["Black Tea", "Green Tea", "Herbal Tea"], + } + + level_0_data = rng.choice(level_0_labels, N) + level_1_data = [rng.choice(level_1_labels[level_0]) for level_0 in level_0_data] + level_2_data = [rng.choice(level_2_labels[level_1]) for level_1 in level_1_data] + + df = pd.DataFrame( + { + "level_0": level_0_data, + "level_1": level_1_data, + "level_2": level_2_data, + "A": rng.normal(size=N), + "B": rng.normal(size=N), + "C": rng.normal(size=N), + "sales": rng.normal(size=N), + } + ) + + return df + + +@pytest.fixture(scope="session") +def encoded_df_and_coords(df): + df_encoded = df.copy() + coords = {} + for col in df_encoded: + if df_encoded[col].dtype == "object": + idx, labels = pd.factorize(df_encoded[col], sort=True) + coords[col] = labels.tolist() + df_encoded[col] = idx + + coords["feature"] = df.drop(columns=["sales"]).columns.tolist() + coords["obs_idx"] = df.index.tolist() + + return df_encoded, coords + + +@pytest.fixture(scope="session") +def model(encoded_df_and_coords, rng): + df, coords = encoded_df_and_coords + + with pm.Model(coords=coords) as m: + X = pm.Data("X", df[coords["feature"]], dims=["obs_idx", "features"]) + + return m + + +@pytest.mark.parametrize("cols", ["A", ["A", "B"]], ids=["single", "multiple"]) +def test_select_data_columns(model, cols): + col = select_data_columns(cols, model, data_name="X") + + idxs = [model.coords["feature"].index(col) for col in cols] + assert_allclose(col.eval(), model["X"].get_value()[:, idxs].squeeze()) + + +def test_select_missing_column_raises(model): + with pytest.raises(ValueError): + select_data_columns("D", model, data_name="X") + + +def test_make_level_maps(model, encoded_df_and_coords, df): + df_encoded, coords = encoded_df_and_coords + data = pytensor.shared(df_encoded.values) + + level_maps = make_level_maps(data, coords, ordered_levels=["level_0", "level_1", "level_2"]) + + level_maps = [x.eval() for x in level_maps[1:]] + m0, m1, m2 = level_maps + + # Rebuild the labels from the level maps + new_labels = np.array(coords["level_0"])[m0] + new_labels = np.array([x + "_" + y for x, y in zip(new_labels, coords["level_1"])])[m1] + new_labels = np.array([x + "_" + y for x, y in zip(new_labels, coords["level_2"])])[m2] + + new_labels = pd.Series(new_labels).apply( + lambda x: pd.Series(x.split("_"), index=["level_0", "level_1", "level_2"]) + ) + + pd.testing.assert_frame_equal(new_labels, df[["level_0", "level_1", "level_2"]]) + + +def test_make_simple_hierarchical_variable(): + with pm.Model(coords={"level_0": ["A", "B", "C"]}) as m: + mapping = np.random.choice(3, size=(10,)) + effect_mu = pm.Normal("effect_mu") + mu = make_next_level_hierarchy_variable( + "effect", mu=effect_mu, offset_dims="level_0", sigma_dims=None, mapping=None + ) + mu = mu[mapping] + + expected_names = ["effect_mu", "effect_sigma", "effect_offset"] + assert all([x.name in expected_names for x in m.free_RVs]) + + +def test_make_two_level_hierarchical_variable(): + with pm.Model(coords={"level_0": ["A", "B", "C"], "level_1": range(9)}) as m: + mapping = np.random.choice(3, size=(10,)) + + level_0_mu = pm.Normal("level_0_effect_mu") + mu = make_next_level_hierarchy_variable( + "level_0_effect", mu=level_0_mu, offset_dims="level_0", sigma_dims=None, mapping=None + ) + + mu = make_next_level_hierarchy_variable( + "level_1_effect", mu=mu, offset_dims="level_1", sigma_dims="level_0", mapping=mapping + ) + + expected_names = [ + "level_0_effect_mu", + "level_0_effect_sigma", + "level_0_effect_offset", + "level_0_effect", + "level_1_effect_sigma", + "level_1_effect_offset", + ] + assert all([x.name in expected_names for x in m.free_RVs]) + + m0, s0, o0, m1, s1, o1 = (m[name] for name in expected_names) + assert m1.shape.eval() == (3,) + assert s1.shape.eval() == (3,) + assert o1.shape.eval() == (9,) + + +def test_make_next_level_no_pooling(): + with pm.Model(coords={"level_0": ["A", "B", "C"]}) as m: + effect_mu = pm.Normal("effect_mu", shape=(3,)) + mu = make_next_level_hierarchy_variable( + "effect", + mu=effect_mu, + offset_dims="level_0", + sigma_dims=None, + mapping=[0, 0, 0, 1, 1, 1, 2, 2, 2], + no_pooling=True, + ) + + assert "effect_sigma" not in m.named_vars + assert "effect_offset" not in m.named_vars + assert mu.shape.eval() == (9,) + + +@pytest.mark.parametrize( + "pooling_columns", [["level_0"], ["level_0", "level_1"], ["level_0", "level_1", "level_2"]] +) +def test_hierarchical_prior_to_requested_depth(model, encoded_df_and_coords, pooling_columns): + temp_model = model.copy() + with temp_model: + intercept = hierarchical_prior_to_requested_depth( + name="intercept", X=model["X"], pooling_columns=pooling_columns + ) + + intercept = intercept.eval() + assert intercept.shape[0] == len(model.coords["obs_idx"]) + assert len(np.unique(intercept)) == len(model.coords[pooling_columns[-1]]) From 155dcd6c62cb0e5bdd7195f0e38a3c99c2d732af Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Thu, 12 Dec 2024 00:28:26 -0500 Subject: [PATCH 5/9] Refactor intercept class --- pymc_experimental/model/modular/components.py | 73 +++---- pymc_experimental/model/modular/likelihood.py | 24 +-- pymc_experimental/model/modular/utilities.py | 191 ++++++++++++++---- tests/model/modular/test_components.py | 55 +++++ tests/model/modular/test_utilities.py | 39 ++-- 5 files changed, 252 insertions(+), 130 deletions(-) create mode 100644 tests/model/modular/test_components.py diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index 9e6620ba..d818ce88 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -1,44 +1,18 @@ from abc import ABC, abstractmethod -from typing import Literal, get_args import pandas as pd import pymc as pm from model.modular.utilities import ( + PRIOR_DEFAULT_KWARGS, ColumnType, + PoolingType, get_X_data, - hierarchical_prior_to_requested_depth, + make_hierarchical_prior, select_data_columns, ) from patsy import dmatrix -PoolingType = Literal["none", "complete", "partial", None] -valid_pooling = get_args(PoolingType) - - -def _validate_pooling_params(pooling_columns: ColumnType, pooling: PoolingType): - """ - Helper function to validate inputs to a GLM component. - - Parameters - ---------- - pooling_columns: str or list of str - Data columns used to construct a hierarchical prior - pooling: str - Type of pooling to use in the component - - Returns - ------- - None - """ - if pooling_columns is not None and pooling == "complete": - raise ValueError("Index data provided but complete pooling was requested") - if pooling_columns is None and pooling != "complete": - raise ValueError( - "Index data must be provided for partial pooling (pooling = 'partial') or no pooling " - "(pooling = 'none')" - ) - class GLMModel(ABC): """Base class for GLM components. Subclasses should implement the build method to construct the component.""" @@ -91,7 +65,7 @@ def __init__( self, name: str | None = None, *, - pooling_cols: ColumnType = None, + pooling_columns: ColumnType = None, pooling: PoolingType = "complete", hierarchical_params: dict | None = None, prior: str = "Normal", @@ -108,7 +82,7 @@ def __init__( ---------- name: str, optional Name of the intercept term. If None, a default name is generated based on the index_data. - pooling_cols: str or list of str, optional + pooling_columns: str or list of str, optional Columns of the independent data to use as labels for pooling. These columns will be treated as categorical. If None, no pooling is applied. If a list is provided, a "telescoping" hierarchy is constructed from left to right, with the mean of each subsequent level centered on the mean of the previous level. @@ -133,21 +107,19 @@ def __init__( Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. """ - _validate_pooling_params(pooling_cols, pooling) - - self.pooling_cols = pooling_cols self.hierarchical_params = hierarchical_params if hierarchical_params is not None else {} - self.pooling = pooling if pooling_cols is not None else "complete" + self.pooling = pooling self.prior = prior self.prior_params = prior_params if prior_params is not None else {} - if pooling_cols is None: - pooling_cols = [] - elif isinstance(pooling_cols, str): - pooling_cols = [pooling_cols] + if pooling_columns is None: + pooling_columns = [] + elif isinstance(pooling_columns, str): + pooling_columns = [pooling_columns] - name = name or f"Intercept(pooling_cols={pooling_cols})" + self.pooling_columns = pooling_columns + name = name or f"Intercept(pooling_cols={pooling_columns})" super().__init__(name=name) @@ -155,15 +127,21 @@ def build(self, model: pm.Model | None = None): model = pm.modelcontext(model) with model: if self.pooling == "complete": - intercept = getattr(pm, self.prior.title())(f"{self.name}", **self.prior_params) + prior_params = PRIOR_DEFAULT_KWARGS[self.prior].copy() + prior_params.update(self.prior_params) + + intercept = getattr(pm, self.prior)(f"{self.name}", **prior_params) return intercept - intercept = hierarchical_prior_to_requested_depth( + intercept = make_hierarchical_prior( self.name, - df=get_X_data(model)[self.pooling_cols], + X=get_X_data(model), model=model, + pooling_columns=self.pooling_columns, dims=None, - no_pooling=self.pooling == "none", + pooling=self.pooling, + prior=self.prior, + prior_kwargs=self.prior_params, **self.hierarchical_params, ) @@ -219,8 +197,6 @@ def __init__( prior_params: Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. """ - _validate_pooling_params(pooling_columns, pooling) - self.feature_columns = feature_columns self.pooling = pooling self.pooling_columns = pooling_columns @@ -248,7 +224,7 @@ def build(self, model=None): ) return X @ beta - beta = hierarchical_prior_to_requested_depth( + beta = make_hierarchical_prior( self.name, self.index_data, model=model, @@ -318,7 +294,6 @@ def __init__( offset_dist: str, one of ["zerosum", "normal", "laplace"] Name of the distribution to use for the offset distribution. Default is "zerosum" """ - _validate_pooling_params(index_data, pooling) self.name = name if name else f"Spline({feature_column})" self.feature_column = feature_column self.n_knots = n_knots @@ -352,7 +327,7 @@ def build(self, model: pm.Model | None = None): elif self.pooling_columns is not None: X = select_data_columns(self.pooling_columns, model) - beta = hierarchical_prior_to_requested_depth( + beta = make_hierarchical_prior( name=self.name, X=X, model=model, diff --git a/pymc_experimental/model/modular/likelihood.py b/pymc_experimental/model/modular/likelihood.py index 8d1b34eb..11a2cff8 100644 --- a/pymc_experimental/model/modular/likelihood.py +++ b/pymc_experimental/model/modular/likelihood.py @@ -3,7 +3,6 @@ from typing import Literal, get_args import arviz as az -import numpy as np import pandas as pd import pymc as pm import pytensor.tensor as pt @@ -14,7 +13,7 @@ from pytensor.tensor.random.type import RandomType from pymc_experimental.model.marginal.marginal_model import MarginalModel -from pymc_experimental.model.modular.utilities import ColumnType +from pymc_experimental.model.modular.utilities import ColumnType, encode_categoricals LIKELIHOOD_TYPES = Literal["lognormal", "logt", "mixture", "unmarginalized-mixture"] valid_likelihoods = get_args(LIKELIHOOD_TYPES) @@ -42,7 +41,6 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): [target_col] = target_col self.target_col = target_col - # TODO: Reconsider this (two sources of nearly the same info not good) X_df = data.drop(columns=[target_col]) self.obs_dim = data.index.name @@ -50,25 +48,7 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): self.obs_dim: data.index.values, } - for col, dtype in X_df.dtypes.to_dict().items(): - if dtype.name.startswith("float"): - pass - elif dtype.name == "object": - # TODO: We definitely need to save these if we want to factorize predict data - col_array, labels = pd.factorize(X_df[col], sort=True) - X_df[col] = col_array.astype("float64") - self.coords[col] = labels - elif dtype.name.startswith("int"): - _data = X_df[col].copy() - X_df[col] = X_df[col].astype("float64") - assert np.all( - _data == X_df[col].astype("int") - ), "Information was lost in conversion to float" - - else: - raise NotImplementedError( - f"Haven't decided how to handle the following type: {dtype.name}" - ) + X_df, self.coords = encode_categoricals(X_df, self.coords) numeric_cols = [ col for col, dtype in X_df.dtypes.to_dict().items() if dtype.name.startswith("float") diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index e65a9b2d..271aa859 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -1,7 +1,11 @@ import itertools from collections.abc import Sequence +from copy import deepcopy +from typing import Literal, get_args +import numpy as np +import pandas as pd import pymc as pm import pytensor.tensor as pt @@ -9,6 +13,9 @@ ColumnType = str | list[str] +PoolingType = Literal["none", "complete", "partial", None] +valid_pooling = get_args(PoolingType) + # Dictionary to define offset distributions for hierarchical models OFFSET_DIST_FACTORY = { "zerosum": lambda name, offset_dims: pm.ZeroSumNormal(f"{name}_offset", dims=offset_dims), @@ -24,6 +31,12 @@ "HalfCauchy": {"beta": 1}, } +PRIOR_DEFAULT_KWARGS = { + "Normal": {"mu": 0, "sigma": 1}, + "Laplace": {"mu": 0, "b": 1}, + "StudentT": {"nu": 3, "mu": 0, "sigma": 1}, +} + def select_data_columns( cols: str | Sequence[str] | None, @@ -46,7 +59,7 @@ def select_data_columns( A tensor variable representing the selected columns of the independent data """ model = pm.modelcontext(model) - if isinstance(cols, None): + if cols is None: return if isinstance(cols, str): @@ -69,6 +82,34 @@ def get_X_data(model, data_name="X_data") -> SharedVariable: return model[data_name] +def encode_categoricals(df, coords): + df = df.copy() + coords = deepcopy(coords) + + for col, dtype in df.dtypes.items(): + if dtype.name.startswith("float"): + pass + + elif dtype.name == "object": + col_array, labels = pd.factorize(df[col], sort=True) + df[col] = col_array.astype("float64") + coords[col] = labels + + elif dtype.name.startswith("int"): + _data = df[col].copy() + df[col] = df[col].astype("float64") + assert np.all( + _data == df[col].astype("int") + ), "Information was lost in conversion to float" + + else: + raise NotImplementedError( + f"Haven't decided how to handle the following type: {dtype.name}" + ) + + return df, coords + + def make_level_maps(X: SharedVariable, coords: dict[str, tuple | None], ordered_levels: list[str]): r""" For each row of data, create a mapping between levels of a arbitrary set of levels defined by `ordered_levels`. @@ -108,14 +149,11 @@ def make_level_maps(X: SharedVariable, coords: dict[str, tuple | None], ordered_ `len(ordered_levels) - 1` list of arrays indexing each previous level to the next level. The i-th array in the list has shape len(df[ordered_levels[i+1]].unique()) """ - level_idxs = [coords["feature"].index(level) for level in ordered_levels] - level_pairs = itertools.pairwise(level_idxs) - mappings = [None] - for pair in level_pairs: - edges = pt.unique(X[:, list(pair)], axis=0) + for level_im1, level_i in itertools.pairwise(level_idxs): + edges = pt.unique(X[:, [level_im1, level_i]], axis=0) sorted_idx = pt.argsort(edges[:, 1]) mappings.append(edges[sorted_idx, 0].astype(int)) @@ -123,23 +161,7 @@ def make_level_maps(X: SharedVariable, coords: dict[str, tuple | None], ordered_ return mappings -def make_next_level_hierarchy_variable( - name: str, - mu, - sigma_dist: str = "Gamma", - sigma_kwargs: dict | None = None, - mapping=None, - sigma_dims=None, - offset_dims=None, - offset_dist="Normal", - no_pooling=False, -): - if no_pooling: - if mapping is None: - return pm.Deterministic(f"{name}", mu[..., None], dims=offset_dims) - else: - return pm.Deterministic(f"{name}", mu[..., mapping], dims=offset_dims) - +def make_sigma(name, sigma_dist, sigma_kwargs, sigma_dims): d_sigma = getattr(pm, sigma_dist) if sigma_kwargs is None: @@ -149,8 +171,20 @@ def make_next_level_hierarchy_variable( ) sigma_kwargs = SIGMA_DEFAULT_KWARGS[sigma_dist] - sigma_ = d_sigma(f"{name}_sigma", **sigma_kwargs, dims=sigma_dims) + return d_sigma(f"{name}_sigma", **sigma_kwargs, dims=sigma_dims) + +def make_next_level_hierarchy_variable( + name: str, + mu, + sigma_dist: str = "Gamma", + sigma_kwargs: dict | None = None, + mapping=None, + sigma_dims=None, + offset_dims=None, + offset_dist="Normal", +): + sigma_ = make_sigma(name, sigma_dist, sigma_kwargs, sigma_dims) offset_dist = offset_dist.lower() if offset_dist not in OFFSET_DIST_FACTORY: raise NotImplementedError() @@ -167,16 +201,17 @@ def make_next_level_hierarchy_variable( ) -def hierarchical_prior_to_requested_depth( +def make_partial_pooled_hierarchy( name: str, X: SharedVariable, + model: pm.Model, pooling_columns: ColumnType = None, - model: pm.Model = None, + prior: str = "Normal", + prior_kwargs: dict = {}, dims: list[str] | None = None, - no_pooling: bool = False, **hierarchy_kwargs, ) -> pt.TensorVariable: - """ + r""" Given a dataframe of categorical data, construct a hierarchical prior that pools data telescopically, moving from left to right across the columns of the dataframe. @@ -207,7 +242,7 @@ def hierarchical_prior_to_requested_depth( .. code-block:: Apple Banana - / \\ / \ + / \ / \ Red Green Yellow Brown @@ -236,9 +271,6 @@ def hierarchical_prior_to_requested_depth( Additional dimensions to add to the variable. These are treated as batch dimensions, and are added to the left of the hierarchy dimensions. For example, if dims=['feature'], and df has one column named "country", the returned variables will have dimensions ['feature', 'country'] - no_pooling: bool, optional - If True, no pooling is applied to the variable. Each level of the hierarchy is treated as independent, with no - informaton shared across level members of a given level. hierarchy_kwargs: dict Additional keyword arguments to pass to the underlying PyMC distribution. Options include: sigma_dist: str @@ -255,10 +287,11 @@ def hierarchical_prior_to_requested_depth( PyMC distribution representing the hierarchical prior. The shape of the distribution will be (n_obs, *dims, df.loc[:, -1].nunique()) """ - - model = pm.modelcontext(model) coords = model.coords + if X.ndim == 1: + X = X[:, None] + sigma_dist = hierarchy_kwargs.pop("sigma_dist", "Gamma") sigma_kwargs = hierarchy_kwargs.pop("sigma_kwargs", {"alpha": 2, "beta": 1}) offset_dist = hierarchy_kwargs.pop("offset_dist", "zerosum") @@ -266,8 +299,13 @@ def hierarchical_prior_to_requested_depth( idx_maps = make_level_maps(X, coords, pooling_columns) deepest_map = idx_maps[-1] + Prior = getattr(pm, prior) + prior_params = deepcopy(PRIOR_DEFAULT_KWARGS.get(prior)) + prior_params.update(prior_kwargs) + with model: - beta = pm.Normal(f"{name}_effect", 0, 1, dims=dims) + beta = Prior(f"{name}_effect", **prior_params, dims=dims) + for i, (last_level, level) in enumerate(itertools.pairwise([None, *pooling_columns])): if i == 0: sigma_dims = dims @@ -288,7 +326,88 @@ def hierarchical_prior_to_requested_depth( sigma_dims=sigma_dims, offset_dims=offset_dims, offset_dist=offset_dist, - no_pooling=no_pooling, ) return beta[..., deepest_map] + + +def make_unpooled_hierarchy( + name: str, + X: SharedVariable, + model: pm.Model = None, + prior: str = "Normal", + levels: str | list[str] | None = None, + dims: list[str] | None = None, + **hierarchy_kwargs, +): + coords = model.coords + + sigma_dist = hierarchy_kwargs.pop("sigma_dist", "Gamma") + sigma_kwargs = hierarchy_kwargs.pop("sigma_kwargs", {"alpha": 2, "beta": 1}) + + if X.ndim == 1: + X = X[:, None] + + idx_maps = make_level_maps(X, coords, levels) + deepest_map = idx_maps[-1] + + Prior = getattr(pm, prior) + prior_kwargs = deepcopy(PRIOR_DEFAULT_KWARGS.get(prior)) + prior_kwargs.update(prior_kwargs) + + with model: + beta = Prior(f"{name}_mu", **prior_kwargs, dims=dims) + + for i, (last_level, level) in enumerate(itertools.pairwise([None, *levels])): + sigma = make_sigma(f"{name}_{level}_sigma", sigma_dist, sigma_kwargs, dims) + + prior_kwargs["mu"] = beta[..., idx_maps[i]] + scale_name = "b" if prior == "Laplace" else "sigma" + prior_kwargs[scale_name] = sigma + + beta_dims = [*dims, level] if dims is not None else [level] + + beta = Prior(f"{name}_{level}_effect", **prior_kwargs, dims=beta_dims) + + return beta[..., deepest_map] + + +def make_completely_pooled_hierarchy( + name: str, + model: pm.Model, + dims: list[str] | None = None, +): + with model: + beta = pm.Normal(f"{name}_mu", 0, 1, dims=dims) + + return beta + + +def make_hierarchical_prior( + name: str, + X: SharedVariable, + pooling: PoolingType, + prior: str = "Normal", + pooling_columns: ColumnType = None, + model: pm.Model = None, + dims: list[str] | None = None, + **hierarchy_kwargs, +): + model = pm.modelcontext(model) + + if pooling == "none": + return make_unpooled_hierarchy( + name=name, X=X, model=model, levels=pooling_columns, prior=prior, dims=dims + ) + elif pooling == "partial": + return make_partial_pooled_hierarchy( + name=name, + X=X, + pooling_columns=pooling_columns, + model=model, + prior=prior, + dims=dims, + **hierarchy_kwargs, + ) + else: + raise NotImplementedError(f"{pooling} pooling not yet implemented") diff --git a/tests/model/modular/test_components.py b/tests/model/modular/test_components.py new file mode 100644 index 00000000..183a07b0 --- /dev/null +++ b/tests/model/modular/test_components.py @@ -0,0 +1,55 @@ +import numpy as np +import pandas as pd +import pymc as pm +import pytest + +from model.modular.utilities import encode_categoricals + +from pymc_experimental.model.modular.components import Intercept, PoolingType + + +@pytest.fixture(scope="session") +def rng(): + return np.random.default_rng() + + +@pytest.fixture(scope="session") +def model(rng): + city = ["A", "B", "C"] + race = ["white", "black", "hispanic"] + + df = pd.DataFrame( + { + "city": np.random.choice(city, 1000), + "age": rng.normal(size=1000), + "race": rng.choice(race, size=1000), + "income": rng.normal(size=1000), + } + ) + + coords = {"feature": df.columns, "obs_idx": df.index} + + df, coords = encode_categoricals(df, coords) + + with pm.Model(coords=coords) as m: + X = pm.Data("X_data", df, dims=["obs_idx", "features"]) + + return m + + +@pytest.mark.parametrize("pooling", ["partial", "none", "complete"], ids=str) +@pytest.mark.parametrize("prior", ["Normal", "Laplace", "StudentT"], ids=str) +def test_intercept(pooling: PoolingType, prior, model): + intercept = Intercept(name=None, pooling=pooling, pooling_columns="city", prior=prior) + + x = intercept.build(model.copy()).eval() + + if pooling != "complete": + assert x.shape[0] == len(model.coords["obs_idx"]) + assert np.unique(x).shape[0] == len(model.coords["city"]) + else: + assert np.unique(x).shape[0] == 1 + + +def test_regression(): + pass diff --git a/tests/model/modular/test_utilities.py b/tests/model/modular/test_utilities.py index af4334eb..ff48e9d0 100644 --- a/tests/model/modular/test_utilities.py +++ b/tests/model/modular/test_utilities.py @@ -7,9 +7,11 @@ from numpy.testing import assert_allclose from pymc_experimental.model.modular.utilities import ( - hierarchical_prior_to_requested_depth, + encode_categoricals, make_level_maps, make_next_level_hierarchy_variable, + make_partial_pooled_hierarchy, + make_unpooled_hierarchy, select_data_columns, ) @@ -61,18 +63,7 @@ def df(rng): @pytest.fixture(scope="session") def encoded_df_and_coords(df): - df_encoded = df.copy() - coords = {} - for col in df_encoded: - if df_encoded[col].dtype == "object": - idx, labels = pd.factorize(df_encoded[col], sort=True) - coords[col] = labels.tolist() - df_encoded[col] = idx - - coords["feature"] = df.drop(columns=["sales"]).columns.tolist() - coords["obs_idx"] = df.index.tolist() - - return df_encoded, coords + return encode_categoricals(df, {"feature": df.columns.tolist(), "obs_idx": df.index.tolist()}) @pytest.fixture(scope="session") @@ -162,20 +153,22 @@ def test_make_two_level_hierarchical_variable(): def test_make_next_level_no_pooling(): - with pm.Model(coords={"level_0": ["A", "B", "C"]}) as m: - effect_mu = pm.Normal("effect_mu", shape=(3,)) - mu = make_next_level_hierarchy_variable( + data = pd.DataFrame({"level_0": np.random.choice(["A", "B", "C"], size=(10,))}) + data, coords = encode_categoricals(data, {"feature": data.columns, "obs_idx": data.index}) + + with pm.Model(coords=coords) as m: + X = pm.Data("X_data", data, dims=["obs_idx", "feature"]) + mu = make_unpooled_hierarchy( "effect", - mu=effect_mu, - offset_dims="level_0", + X=X, + levels=["level_0"], + model=m, sigma_dims=None, - mapping=[0, 0, 0, 1, 1, 1, 2, 2, 2], - no_pooling=True, ) assert "effect_sigma" not in m.named_vars assert "effect_offset" not in m.named_vars - assert mu.shape.eval() == (9,) + assert mu.shape.eval() == (10,) @pytest.mark.parametrize( @@ -184,8 +177,8 @@ def test_make_next_level_no_pooling(): def test_hierarchical_prior_to_requested_depth(model, encoded_df_and_coords, pooling_columns): temp_model = model.copy() with temp_model: - intercept = hierarchical_prior_to_requested_depth( - name="intercept", X=model["X"], pooling_columns=pooling_columns + intercept = make_partial_pooled_hierarchy( + name="intercept", X=model["X"], pooling_columns=pooling_columns, model=temp_model ) intercept = intercept.eval() From 8a630ce76f3c59524ceee9d4aef19c0734d02e13 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Thu, 12 Dec 2024 16:38:10 -0500 Subject: [PATCH 6/9] Refactor regression component --- pymc_experimental/model/modular/components.py | 37 +++++++-------- pymc_experimental/model/modular/utilities.py | 25 +++++++--- tests/model/modular/test_components.py | 46 +++++++++++++++++-- 3 files changed, 80 insertions(+), 28 deletions(-) diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index d818ce88..132306f5 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -7,6 +7,7 @@ PRIOR_DEFAULT_KWARGS, ColumnType, PoolingType, + at_least_list, get_X_data, make_hierarchical_prior, select_data_columns, @@ -112,13 +113,8 @@ def __init__( self.prior = prior self.prior_params = prior_params if prior_params is not None else {} + self.pooling_columns = at_least_list(pooling_columns) - if pooling_columns is None: - pooling_columns = [] - elif isinstance(pooling_columns, str): - pooling_columns = [pooling_columns] - - self.pooling_columns = pooling_columns name = name or f"Intercept(pooling_cols={pooling_columns})" super().__init__(name=name) @@ -158,7 +154,7 @@ def __init__( pooling: PoolingType = "complete", pooling_columns: ColumnType | None = None, hierarchical_params: dict | None = None, - **prior_params, + prior_params: dict | None = None, ): """ Class to represent a regression component in a GLM model. @@ -197,12 +193,13 @@ def __init__( prior_params: Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. """ - self.feature_columns = feature_columns + self.feature_columns = at_least_list(feature_columns) self.pooling = pooling - self.pooling_columns = pooling_columns + self.pooling_columns = at_least_list(pooling_columns) self.prior = prior - self.prior_params = prior_params + self.prior_params = {} if prior_params is None else prior_params + self.hierarchical_params = {} if hierarchical_params is None else hierarchical_params name = name if name else f"Regression({feature_columns})" @@ -213,23 +210,27 @@ def build(self, model=None): feature_dim = f"{self.name}_features" if feature_dim not in model.coords: - model.add_coord(feature_dim, self.X.columns) + model.add_coord(feature_dim, self.feature_columns) with model: - X = select_data_columns(get_X_data(model), self.feature_columns) + full_X = get_X_data(model) + X = select_data_columns(self.feature_columns, model, squeeze=False) if self.pooling == "complete": - beta = getattr(pm, self.prior)( - f"{self.name}", **self.prior_params, dims=[feature_dim] - ) + prior_params = PRIOR_DEFAULT_KWARGS[self.prior].copy() + prior_params.update(self.prior_params) + + beta = getattr(pm, self.prior)(f"{self.name}", **prior_params, dims=[feature_dim]) return X @ beta beta = make_hierarchical_prior( - self.name, - self.index_data, + name=self.name, + X=full_X, + pooling=self.pooling, + pooling_columns=self.pooling_columns, model=model, dims=[feature_dim], - no_pooling=self.pooling == "none", + **self.hierarchical_params, ) regression_effect = (X * beta.T).sum(axis=-1) diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index 271aa859..79384646 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -42,6 +42,7 @@ def select_data_columns( cols: str | Sequence[str] | None, model: pm.Model | None = None, data_name: str = "X_data", + squeeze=True, ) -> pt.TensorVariable | None: """ Create a tensor variable representing a subset of independent data columns. @@ -72,7 +73,7 @@ def select_data_columns( cols_idx = [model.coords["feature"].index(col) for col in cols] # Single columns are returned as 1d arrays - if len(cols_idx) == 1: + if len(cols_idx) == 1 and squeeze: cols_idx = cols_idx[0] return get_X_data(model, data_name=data_name)[:, cols_idx] @@ -110,6 +111,14 @@ def encode_categoricals(df, coords): return df, coords +def at_least_list(columns: ColumnType): + if columns is None: + columns = [] + elif isinstance(columns, str): + columns = [columns] + return columns + + def make_level_maps(X: SharedVariable, coords: dict[str, tuple | None], ordered_levels: list[str]): r""" For each row of data, create a mapping between levels of a arbitrary set of levels defined by `ordered_levels`. @@ -304,7 +313,7 @@ def make_partial_pooled_hierarchy( prior_params.update(prior_kwargs) with model: - beta = Prior(f"{name}_effect", **prior_params, dims=dims) + beta = Prior(f"{name}", **prior_params, dims=dims) for i, (last_level, level) in enumerate(itertools.pairwise([None, *pooling_columns])): if i == 0: @@ -359,13 +368,17 @@ def make_unpooled_hierarchy( beta = Prior(f"{name}_mu", **prior_kwargs, dims=dims) for i, (last_level, level) in enumerate(itertools.pairwise([None, *levels])): - sigma = make_sigma(f"{name}_{level}_sigma", sigma_dist, sigma_kwargs, dims) + if i == 0: + sigma_dims = dims + else: + sigma_dims = [*dims, last_level] if dims is not None else [last_level] + beta_dims = [*dims, level] if dims is not None else [level] + + sigma = make_sigma(f"{name}_{level}_effect", sigma_dist, sigma_kwargs, sigma_dims) prior_kwargs["mu"] = beta[..., idx_maps[i]] scale_name = "b" if prior == "Laplace" else "sigma" - prior_kwargs[scale_name] = sigma - - beta_dims = [*dims, level] if dims is not None else [level] + prior_kwargs[scale_name] = sigma[..., idx_maps[i]] beta = Prior(f"{name}_{level}_effect", **prior_kwargs, dims=beta_dims) diff --git a/tests/model/modular/test_components.py b/tests/model/modular/test_components.py index 183a07b0..64355e1b 100644 --- a/tests/model/modular/test_components.py +++ b/tests/model/modular/test_components.py @@ -3,9 +3,9 @@ import pymc as pm import pytest -from model.modular.utilities import encode_categoricals +from model.modular.utilities import at_least_list, encode_categoricals -from pymc_experimental.model.modular.components import Intercept, PoolingType +from pymc_experimental.model.modular.components import Intercept, PoolingType, Regression @pytest.fixture(scope="session") @@ -51,5 +51,43 @@ def test_intercept(pooling: PoolingType, prior, model): assert np.unique(x).shape[0] == 1 -def test_regression(): - pass +@pytest.mark.parametrize("pooling", ["partial", "none", "complete"], ids=str) +@pytest.mark.parametrize("prior", ["Normal", "Laplace", "StudentT"], ids=str) +@pytest.mark.parametrize( + "feature_columns", ["income", ["age", "income"]], ids=["single", "multiple"] +) +def test_regression(pooling: PoolingType, prior, feature_columns, model): + regression = Regression( + name=None, + feature_columns=feature_columns, + prior=prior, + pooling=pooling, + pooling_columns="city", + ) + + temp_model = model.copy() + xb = regression.build(temp_model) + assert f"Regression({feature_columns})_features" in temp_model.coords.keys() + + if pooling != "complete": + assert f"Regression({feature_columns})_city_effect" in temp_model.named_vars + assert f"Regression({feature_columns})_city_effect_sigma" in temp_model.named_vars + + if pooling == "partial": + assert ( + f"Regression({feature_columns})_city_effect_offset" in temp_model.named_vars_to_dims + ) + else: + assert f"Regression({feature_columns})" in temp_model.named_vars + + xb_val = xb.eval() + + X, beta = xb.owner.inputs[0].owner.inputs + beta_val = beta.eval() + n_features = len(at_least_list(feature_columns)) + + if pooling != "complete": + assert xb_val.shape[0] == len(model.coords["obs_idx"]) + assert np.unique(beta_val).shape[0] == len(model.coords["city"]) * n_features + else: + assert np.unique(beta_val).shape[0] == n_features From ab3b4ed15ff46292532b607d9bae4b87d2b3ce56 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Thu, 12 Dec 2024 17:35:39 -0500 Subject: [PATCH 7/9] Refactor spline component --- pymc_experimental/model/modular/components.py | 124 ++++++++++++------ pymc_experimental/model/modular/utilities.py | 4 +- tests/model/modular/test_components.py | 15 ++- 3 files changed, 99 insertions(+), 44 deletions(-) diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index 132306f5..4d8500f2 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -1,7 +1,8 @@ from abc import ABC, abstractmethod -import pandas as pd +import numpy as np import pymc as pm +import pytensor.tensor as pt from model.modular.utilities import ( PRIOR_DEFAULT_KWARGS, @@ -13,6 +14,7 @@ select_data_columns, ) from patsy import dmatrix +from pytensor.graph import Apply, Op class GLMModel(ABC): @@ -113,7 +115,7 @@ def __init__( self.prior = prior self.prior_params = prior_params if prior_params is not None else {} - self.pooling_columns = at_least_list(pooling_columns) + self.pooling_columns = pooling_columns name = name or f"Intercept(pooling_cols={pooling_columns})" @@ -193,9 +195,9 @@ def __init__( prior_params: Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. """ - self.feature_columns = at_least_list(feature_columns) + self.feature_columns = feature_columns self.pooling = pooling - self.pooling_columns = at_least_list(pooling_columns) + self.pooling_columns = pooling_columns self.prior = prior self.prior_params = {} if prior_params is None else prior_params @@ -210,7 +212,7 @@ def build(self, model=None): feature_dim = f"{self.name}_features" if feature_dim not in model.coords: - model.add_coord(feature_dim, self.feature_columns) + model.add_coord(feature_dim, at_least_list(self.feature_columns)) with model: full_X = get_X_data(model) @@ -237,17 +239,55 @@ def build(self, model=None): return regression_effect -class Spline(Regression): +class SplineTensor(Op): + def __init__(self, name, df=10, degree=3): + """ + Thin wrapper around patsy dmatrix, allowing for the creation of spline basis functions given a symbolic input. + + Parameters + ---------- + name: str, optional + Name of the spline basis function. + df: int + Number of basis functions to generate + degree: int + Degree of the spline basis + """ + self.name = name if name else "" + self.df = df + self.degree = degree + + def make_node(self, x): + inputs = [pt.as_tensor(x)] + outputs = [pt.dmatrix(f"{self.name}_spline_basis")] + + return Apply(self, inputs, outputs) + + def perform(self, node: Apply, inputs: list[np.ndarray], outputs: list[list[None]]) -> None: + [x] = inputs + + outputs[0][0] = np.asarray( + dmatrix(f"bs({self.name}, df={self.df}, degree={self.degree}) - 1", data={self.name: x}) + ) + + +def pt_spline(x, name=None, df=10, degree=3) -> pt.Variable: + return SplineTensor(name=name, df=df, degree=degree)(x) + + +class Spline(GLMModel): def __init__( self, name: str, *, feature_column: str | None = None, n_knots: int = 10, - prior: str = "Normal", - index_data: pd.Series | None = None, + spline_degree: int = 3, pooling: PoolingType = "complete", - **prior_params, + pooling_columns: ColumnType | None = None, + prior: str = "Normal", + prior_params: dict | None = None, + hierarchical_params: dict | None = None, ): """ Class to represent a spline component in a GLM model. @@ -263,25 +303,23 @@ def __init__( ---------- name: str, optional Name of the intercept term. If None, a default name is generated based on the index_data. - n_knots: int, default 10 - Number of knots to use in the spline basis. feature_column: str Column of the independent data to use in the spline. - index_data: Series or DataFrame, optional - Index data used to build hierarchical priors. If there are multiple columns, the columns are treated as - levels of a "telescoping" hierarchy, with the leftmost column representing the top level of the hierarchy, - and depth increasing to the right. - - The index of the index_data must match the index of the observed data. - prior: str, optional - Name of the PyMC distribution to use for the intercept term. Default is "Normal". + n_knots: int, default 10 + Number of knots to use in the spline basis. + spline_degree: int, default 3 + Degree of the spline basis. pooling: str, one of ["none", "complete", "partial"], default "complete" Type of pooling to use for the intercept term. If "none", no pooling is applied, and each group in the index_data is treated as independent. If "complete", complete pooling is applied, and all data are treated as coming from the same group. If "partial", a hierarchical prior is constructed that shares information across groups in the index_data. - curve_type: str, one of ["log", "abc", "ns", "nss", "box-cox"] - Type of curve to build. For details, see the build_curve function. + pooling_columns: str or list of str, optional + Columns of the independent data to use as labels for pooling. These columns will be treated as categorical. + If None, no pooling is applied. If a list is provided, a "telescoping" hierarchy is constructed from left + to right, with the mean of each subsequent level centered on the mean of the previous level. + prior: str, optional + Name of the PyMC distribution to use for the intercept term. Default is "Normal". prior_params: dict, optional Additional keyword arguments to pass to the PyMC distribution specified by the prior argument. hierarchical_params: dict, optional @@ -295,45 +333,49 @@ def __init__( offset_dist: str, one of ["zerosum", "normal", "laplace"] Name of the distribution to use for the offset distribution. Default is "zerosum" """ - self.name = name if name else f"Spline({feature_column})" self.feature_column = feature_column self.n_knots = n_knots + self.spline_degree = spline_degree + self.prior = prior - self.prior_params = prior_params + self.prior_params = {} if prior_params is None else prior_params + self.hierarchical_params = {} if hierarchical_params is None else hierarchical_params + self.pooling = pooling + self.pooling_columns = pooling_columns + + name = name if name else f"Spline({feature_column}, df={n_knots}, degree={spline_degree})" super().__init__(name=name) def build(self, model: pm.Model | None = None): model = pm.modelcontext(model) - model.add_coord(f"{self.name}_spline", range(self.n_knots)) + spline_dim = f"{self.name}_knots" + model.add_coord(spline_dim, range(self.n_knots)) with model: - spline_data = { - self.feature_column: select_data_columns( - get_X_data(model).get_value(), self.feature_column - ) - } - - X_spline = dmatrix( - f"bs({self.feature_column}, df={self.n_knots}, degree=3) - 1", - data=spline_data, - return_type="dataframe", + X_spline = pt_spline( + select_data_columns(self.feature_column, model), + name=self.feature_column, + df=self.n_knots, + degree=self.spline_degree, ) if self.pooling == "complete": - beta = getattr(pm, self.prior)( - f"{self.name}", **self.prior_params, dims=f"{self.feature_column}_spline" - ) + prior_params = PRIOR_DEFAULT_KWARGS[self.prior].copy() + prior_params.update(self.prior_params) + + beta = getattr(pm, self.prior)(f"{self.name}", **prior_params, dims=[spline_dim]) return X_spline @ beta elif self.pooling_columns is not None: - X = select_data_columns(self.pooling_columns, model) beta = make_hierarchical_prior( name=self.name, - X=X, + X=get_X_data(model), + pooling=self.pooling, + pooling_columns=self.pooling_columns, model=model, - dims=[f"{self.feature_column}_spline"], - no_pooling=self.pooling == "none", + dims=[spline_dim], + **self.hierarchical_params, ) spline_effect = (X_spline * beta.T).sum(axis=-1) diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index 79384646..53347ec3 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -63,8 +63,7 @@ def select_data_columns( if cols is None: return - if isinstance(cols, str): - cols = [cols] + cols = at_least_list(cols) missing_cols = [col for col in cols if col not in model.coords["feature"]] if missing_cols: @@ -407,6 +406,7 @@ def make_hierarchical_prior( **hierarchy_kwargs, ): model = pm.modelcontext(model) + pooling_columns = at_least_list(pooling_columns) if pooling == "none": return make_unpooled_hierarchy( diff --git a/tests/model/modular/test_components.py b/tests/model/modular/test_components.py index 64355e1b..f1959067 100644 --- a/tests/model/modular/test_components.py +++ b/tests/model/modular/test_components.py @@ -5,7 +5,7 @@ from model.modular.utilities import at_least_list, encode_categoricals -from pymc_experimental.model.modular.components import Intercept, PoolingType, Regression +from pymc_experimental.model.modular.components import Intercept, PoolingType, Regression, Spline @pytest.fixture(scope="session") @@ -91,3 +91,16 @@ def test_regression(pooling: PoolingType, prior, feature_columns, model): assert np.unique(beta_val).shape[0] == len(model.coords["city"]) * n_features else: assert np.unique(beta_val).shape[0] == n_features + + +@pytest.mark.parametrize("pooling", ["partial", "none", "complete"], ids=str) +@pytest.mark.parametrize("prior", ["Normal", "Laplace", "StudentT"], ids=str) +def test_spline(pooling: PoolingType, prior, model): + spline = Spline( + name=None, feature_column="income", prior=prior, pooling=pooling, pooling_columns="city" + ) + + temp_model = model.copy() + xb = spline.build(temp_model) + + assert "Spline(income, df=10, degree=3)_knots" in temp_model.coords.keys() From 3df653425403bdbf9f9c53b149e4aa4c9e329993 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Fri, 13 Dec 2024 03:59:27 -0500 Subject: [PATCH 8/9] Refactor likelihood, add small example --- pymc_experimental/model/modular/__init__.py | 9 + pymc_experimental/model/modular/components.py | 9 +- pymc_experimental/model/modular/likelihood.py | 210 +++--------------- pymc_experimental/model/modular/utilities.py | 13 -- tests/model/modular/test_likelihood.py | 31 +++ 5 files changed, 74 insertions(+), 198 deletions(-) create mode 100644 tests/model/modular/test_likelihood.py diff --git a/pymc_experimental/model/modular/__init__.py b/pymc_experimental/model/modular/__init__.py index e69de29b..62bc8109 100644 --- a/pymc_experimental/model/modular/__init__.py +++ b/pymc_experimental/model/modular/__init__.py @@ -0,0 +1,9 @@ +from pymc_experimental.model.modular.components import Intercept, Regression, Spline +from pymc_experimental.model.modular.likelihood import NormalLikelihood + +__all__ = [ + "Intercept", + "Regression", + "Spline", + "NormalLikelihood", +] diff --git a/pymc_experimental/model/modular/components.py b/pymc_experimental/model/modular/components.py index 4d8500f2..01efa77a 100644 --- a/pymc_experimental/model/modular/components.py +++ b/pymc_experimental/model/modular/components.py @@ -4,7 +4,10 @@ import pymc as pm import pytensor.tensor as pt -from model.modular.utilities import ( +from patsy import dmatrix +from pytensor.graph import Apply, Op + +from pymc_experimental.model.modular.utilities import ( PRIOR_DEFAULT_KWARGS, ColumnType, PoolingType, @@ -13,14 +16,12 @@ make_hierarchical_prior, select_data_columns, ) -from patsy import dmatrix -from pytensor.graph import Apply, Op class GLMModel(ABC): """Base class for GLM components. Subclasses should implement the build method to construct the component.""" - def __init__(self, name): + def __init__(self, name=None): self.model = None self.compiled = False self.name = name diff --git a/pymc_experimental/model/modular/likelihood.py b/pymc_experimental/model/modular/likelihood.py index 11a2cff8..d099b3b4 100644 --- a/pymc_experimental/model/modular/likelihood.py +++ b/pymc_experimental/model/modular/likelihood.py @@ -1,11 +1,13 @@ from abc import ABC, abstractmethod from collections.abc import Sequence +from io import StringIO from typing import Literal, get_args import arviz as az import pandas as pd import pymc as pm import pytensor.tensor as pt +import rich from pymc.backends.arviz import apply_function_over_dataset from pymc.model.fgraph import clone_model @@ -14,6 +16,7 @@ from pymc_experimental.model.marginal.marginal_model import MarginalModel from pymc_experimental.model.modular.utilities import ColumnType, encode_categoricals +from pymc_experimental.printing import model_table LIKELIHOOD_TYPES = Literal["lognormal", "logt", "mixture", "unmarginalized-mixture"] valid_likelihoods = get_args(LIKELIHOOD_TYPES) @@ -43,7 +46,7 @@ def __init__(self, target_col: ColumnType, data: pd.DataFrame): X_df = data.drop(columns=[target_col]) - self.obs_dim = data.index.name + self.obs_dim = data.index.name if data.index.name is not None else "obs_idx" self.coords = { self.obs_dim: data.index.values, } @@ -70,6 +73,10 @@ def sample(self, **sample_kwargs): with self.model: return pm.sample(**sample_kwargs) + def sample_prior_predictive(self, **sample_kwargs): + with self.model: + return pm.sample_prior_predictive(**sample_kwargs) + def predict( self, idata: az.InferenceData, @@ -137,212 +144,53 @@ def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalMo """Return the type on model used by the likelihood function""" raise NotImplementedError - def register_mu( - self, - *, - df: pd.DataFrame, - mu=None, - ): + def register_mu(self, mu=None): with self.model: if mu is not None: - return pm.Deterministic("mu", mu.build(df=df), dims=[self.obs_dim]) + return pm.Deterministic("mu", mu.build(self.model), dims=[self.obs_dim]) return pm.Normal("mu", 0, 100) - def register_sigma( - self, - *, - df: pd.DataFrame, - sigma=None, - ): + def register_sigma(self, sigma=None): with self.model: if sigma is not None: - return pm.Deterministic("sigma", pt.exp(sigma.build(df=df)), dims=[self.obs_dim]) - return pm.Exponential("sigma", lam=1) - - -class LogNormalLikelihood(Likelihood): - """Class to represent a log-normal likelihood function for a GLM component.""" - - def __init__( - self, - mu, - sigma, - target_col: ColumnType, - data: pd.DataFrame, - ): - super().__init__(target_col=target_col, data=data) - - with self.model: - self.register_data(data[target_col]) - mu = self.register_mu(mu) - sigma = self.register_sigma(sigma) - - pm.LogNormal( - target_col, - mu=mu, - sigma=sigma, - observed=self.model[f"{target_col}_observed"], - dims=[self.obs_dim], - ) - - def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: - return pm.Model(coords=coords) - - -class LogTLikelihood(Likelihood): - """ - Class to represent a log-t likelihood function for a GLM component. - """ - - def __init__( - self, - mu, - *, - sigma=None, - nu=None, - target_col: ColumnType, - data: pd.DataFrame, - ): - def log_student_t(nu, mu, sigma, shape=None): - return pm.math.exp(pm.StudentT.dist(mu=mu, sigma=sigma, nu=nu, shape=shape)) - - super().__init__(target_col=target_col, data=data) - - with self.model: - mu = self.register_mu(mu=mu, df=data) - sigma = self.register_sigma(sigma=sigma, df=data) - nu = self.register_nu(nu=nu, df=data) - - pm.CustomDist( - target_col, - nu, - mu, - sigma, - observed=self.model[f"{target_col}_observed"], - shape=mu.shape, - dims=[self.obs_dim], - dist=log_student_t, - class_name="LogStudentT", - ) - - def register_nu(self, *, df, nu=None): - with self.model: - if nu is not None: - return pm.Deterministic("nu", pt.exp(nu.build(df=df)), dims=[self.obs_dim]) - return pm.Uniform("nu", 2, 30) - - def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: - return pm.Model(coords=coords) - - -class BaseMixtureLikelihood(Likelihood): - """ - Base class for mixture likelihood functions to hold common methods for registering parameters. - """ - - def register_sigma(self, *, df, sigma=None): - with self.model: - if sigma is None: - sigma_not_outlier = pm.Exponential("sigma_not_outlier", lam=1) - else: - sigma_not_outlier = pm.Deterministic( - "sigma_not_outlier", pt.exp(sigma.build(df=df)), dims=[self.obs_dim] - ) - sigma_outlier_offset = pm.Gamma("sigma_outlier_offset", mu=0.2, sigma=0.5) - sigma = pm.Deterministic( - "sigma", - pt.as_tensor([sigma_not_outlier, sigma_not_outlier * (1 + sigma_outlier_offset)]), - dims=["outlier"], - ) - - return sigma - - def register_p_outlier(self, *, df, p_outlier=None, **param_kwargs): - mean_p = param_kwargs.get("mean_p", 0.1) - concentration = param_kwargs.get("concentration", 50) - - with self.model: - if p_outlier is not None: return pm.Deterministic( - "p_outlier", pt.sigmoid(p_outlier.build(df=df)), dims=[self.obs_dim] + "sigma", pt.exp(sigma.build(self.model)), dims=[self.obs_dim] ) - return pm.Beta("p_outlier", mean_p * concentration, (1 - mean_p) * concentration) - - def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: - coords["outlier"] = [False, True] - return MarginalModel(coords=coords) - + return pm.Exponential("sigma", lam=1) -class MixtureLikelihood(BaseMixtureLikelihood): - """ - Class to represent a mixture likelihood function for a GLM component. The mixture is implemented using pm.Mixture, - and does not allow for automatic marginalization of components. - """ + def __repr__(self): + table = model_table(self.model) + buffer = StringIO() + rich.print(table, file=buffer) - def __init__( - self, - mu, - sigma, - p_outlier, - target_col: ColumnType, - data: pd.DataFrame, - ): - super().__init__(target_col=target_col, data=data) + return buffer.getvalue() - with self.model: - mu = self.register_mu(mu) - sigma = self.register_sigma(sigma) - p_outlier = self.register_p_outlier(p_outlier) + def to_graphviz(self): + return self.model.to_graphviz() - pm.Mixture( - target_col, - w=[1 - p_outlier, p_outlier], - comp_dists=pm.LogNormal.dist(mu[..., None], sigma=sigma.T), - shape=mu.shape, - observed=self.model[f"{target_col}_observed"], - dims=[self.obs_dim], - ) + # def _repr_html_(self): + # return model_table(self.model) -class UnmarginalizedMixtureLikelihood(BaseMixtureLikelihood): +class NormalLikelihood(Likelihood): """ - Class to represent an unmarginalized mixture likelihood function for a GLM component. The mixture is implemented using - a MarginalModel, and allows for automatic marginalization of components. + A model with normally distributed errors """ - def __init__( - self, - mu, - sigma, - p_outlier, - target_col: ColumnType, - data: pd.DataFrame, - ): + def __init__(self, mu, sigma, target_col: ColumnType, data: pd.DataFrame): super().__init__(target_col=target_col, data=data) with self.model: mu = self.register_mu(mu) sigma = self.register_sigma(sigma) - p_outlier = self.register_p_outlier(p_outlier) - - is_outlier = pm.Bernoulli( - "is_outlier", - p_outlier, - dims=["cusip"], - # shape=X_pt.shape[0], # Uncomment after https://github.com/pymc-devs/pymc-experimental/pull/304 - ) - pm.LogNormal( + pm.Normal( target_col, mu=mu, - sigma=pm.math.switch(is_outlier, sigma[1], sigma[0]), + sigma=sigma, observed=self.model[f"{target_col}_observed"], - shape=mu.shape, - dims=[data.index.name], + dims=[self.obs_dim], ) - self.model.marginalize(["is_outlier"]) - def _get_model_class(self, coords: dict[str, Sequence]) -> pm.Model | MarginalModel: - coords["outlier"] = [False, True] - return MarginalModel(coords=coords) + return pm.Model(coords=coords) diff --git a/pymc_experimental/model/modular/utilities.py b/pymc_experimental/model/modular/utilities.py index 53347ec3..4e4265dc 100644 --- a/pymc_experimental/model/modular/utilities.py +++ b/pymc_experimental/model/modular/utilities.py @@ -56,7 +56,6 @@ def select_data_columns( Returns ------- - X: TensorVariable A tensor variable representing the selected columns of the independent data """ model = pm.modelcontext(model) @@ -350,9 +349,6 @@ def make_unpooled_hierarchy( ): coords = model.coords - sigma_dist = hierarchy_kwargs.pop("sigma_dist", "Gamma") - sigma_kwargs = hierarchy_kwargs.pop("sigma_kwargs", {"alpha": 2, "beta": 1}) - if X.ndim == 1: X = X[:, None] @@ -367,17 +363,8 @@ def make_unpooled_hierarchy( beta = Prior(f"{name}_mu", **prior_kwargs, dims=dims) for i, (last_level, level) in enumerate(itertools.pairwise([None, *levels])): - if i == 0: - sigma_dims = dims - else: - sigma_dims = [*dims, last_level] if dims is not None else [last_level] beta_dims = [*dims, level] if dims is not None else [level] - - sigma = make_sigma(f"{name}_{level}_effect", sigma_dist, sigma_kwargs, sigma_dims) - prior_kwargs["mu"] = beta[..., idx_maps[i]] - scale_name = "b" if prior == "Laplace" else "sigma" - prior_kwargs[scale_name] = sigma[..., idx_maps[i]] beta = Prior(f"{name}_{level}_effect", **prior_kwargs, dims=beta_dims) diff --git a/tests/model/modular/test_likelihood.py b/tests/model/modular/test_likelihood.py new file mode 100644 index 00000000..594fcbc7 --- /dev/null +++ b/tests/model/modular/test_likelihood.py @@ -0,0 +1,31 @@ +import numpy as np +import pandas as pd +import pytest + +from pymc_experimental.model.modular.likelihood import NormalLikelihood + + +@pytest.fixture(scope="session") +def rng(): + return np.random.default_rng() + + +@pytest.fixture(scope="session") +def data(rng): + city = ["A", "B", "C"] + race = ["white", "black", "hispanic"] + + df = pd.DataFrame( + { + "city": np.random.choice(city, 1000), + "age": rng.normal(size=1000), + "race": rng.choice(race, size=1000), + "income": rng.normal(size=1000), + } + ) + return df + + +def test_normal_likelihood(data): + model = NormalLikelihood(mu=None, sigma=None, target_col="income", data=data) + idata = model.sample_prior_predictive() From 83264a24f612ef7ea1957e07ef6d3e67c3a48838 Mon Sep 17 00:00:00 2001 From: jessegrabowski Date: Fri, 13 Dec 2024 04:01:10 -0500 Subject: [PATCH 9/9] Add example notebook --- notebooks/modular_models.ipynb | 743 +++++++++++++++++++++++++++++++++ 1 file changed, 743 insertions(+) create mode 100644 notebooks/modular_models.ipynb diff --git a/notebooks/modular_models.ipynb b/notebooks/modular_models.ipynb new file mode 100644 index 00000000..db78797e --- /dev/null +++ b/notebooks/modular_models.ipynb @@ -0,0 +1,743 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8e2a953e30184bfa", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:55.806839Z", + "start_time": "2024-12-13T08:58:51.905421Z" + } + }, + "outputs": [], + "source": [ + "from pymc_experimental.model import modular\n", + "import pymc as pm\n", + "import pandas as pd\n", + "import numpy as np\n", + "import arviz as az\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8555f63c675c8333", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:55.811081Z", + "start_time": "2024-12-13T08:58:55.808087Z" + } + }, + "outputs": [], + "source": [ + "def load_radon():\n", + " srrs2 = pd.read_csv(pm.get_data(\"srrs2.dat\"))\n", + " srrs2.columns = srrs2.columns.map(str.strip)\n", + " srrs_mn = srrs2[srrs2.state == \"MN\"].copy()\n", + "\n", + " cty = pd.read_csv(pm.get_data(\"cty.dat\"))\n", + "\n", + " srrs_mn[\"fips\"] = srrs_mn.stfips * 1000 + srrs_mn.cntyfips\n", + " cty_mn = cty[cty.st == \"MN\"].copy()\n", + " cty_mn[\"fips\"] = 1000 * cty_mn.stfips + cty_mn.ctfips\n", + "\n", + " srrs_mn = srrs_mn.merge(cty_mn[[\"fips\", \"Uppm\"]], on=\"fips\")\n", + " srrs_mn = srrs_mn.drop_duplicates(subset=\"idnum\")\n", + "\n", + " srrs_mn.county = srrs_mn.county.map(str.strip)\n", + " county, mn_counties = srrs_mn.county.factorize()\n", + " srrs_mn[\"county_code\"] = county\n", + " srrs_mn[\"log_radon\"] = log_radon = np.log(srrs_mn.activity + 0.1).values\n", + "\n", + " df = srrs_mn[[\"county\", \"floor\", \"log_radon\"]].copy()\n", + " floor_dict = {0: \"Basement\", 1: \"Floor\"}\n", + " df[\"floor\"] = df[\"floor\"].apply(floor_dict.get)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:57.479374Z", + "start_time": "2024-12-13T08:58:55.811711Z" + } + }, + "outputs": [], + "source": [ + "df = load_radon()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5fcb56261883ee4", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:57.508775Z", + "start_time": "2024-12-13T08:58:57.480084Z" + } + }, + "outputs": [], + "source": [ + "alpha = modular.Intercept(\"alpha\")\n", + "floor_effect = modular.Regression(\"floor_effect\", feature_columns=\"floor\")\n", + "\n", + "model_1 = modular.NormalLikelihood(\n", + " mu=alpha + floor_effect, sigma=None, data=df, target_col=\"log_radon\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "139d0744f0c701d7", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:57.536641Z", + "start_time": "2024-12-13T08:58:57.510820Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
             Variable  Expression              Dimensions                \n",
+       "─────────────────────────────────────────────────────────────────────────\n",
+       " log_radon_observed =  Data                    obs_idx[919]              \n",
+       "             X_data =  Data                    obs_idx[919] × feature[2] \n",
+       "                                                                         \n",
+       "              alpha ~  Normal(0, 1)                                      \n",
+       "       floor_effect ~  Normal(0, 1)            floor_effect_features[1]  \n",
+       "              sigma ~  Exponential(f())                                  \n",
+       "                                               Parameter count = 3       \n",
+       "                                                                         \n",
+       "                 mu =  f(alpha, floor_effect)  obs_idx[919]              \n",
+       "                                                                         \n",
+       "          log_radon ~  Normal(mu, sigma)       obs_idx[919]              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m \u001b[0m\u001b[1m Variable\u001b[0m\u001b[1m \u001b[0m \u001b[1mExpression \u001b[0m\u001b[1m \u001b[0m \u001b[1mDimensions \u001b[0m\u001b[1m \u001b[0m\n", + "─────────────────────────────────────────────────────────────────────────\n", + " log_radon_observed\u001b[1m =\u001b[0m Data obs_idx[919] \n", + " X_data\u001b[1m =\u001b[0m Data obs_idx[919] × feature[2] \n", + " \n", + " alpha\u001b[1m ~\u001b[0m Normal(0, 1) \n", + " floor_effect\u001b[1m ~\u001b[0m Normal(0, 1) floor_effect_features[1] \n", + " sigma\u001b[1m ~\u001b[0m Exponential(f()) \n", + " \u001b[3mParameter count = 3\u001b[0m \n", + " \n", + " mu\u001b[1m =\u001b[0m f(alpha, floor_effect) obs_idx[919] \n", + " \n", + " log_radon\u001b[1m ~\u001b[0m Normal(mu, sigma) obs_idx[919] \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b8b2ce0ec9bef664", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:58:57.992337Z", + "start_time": "2024-12-13T08:58:57.537457Z" + } + }, + "outputs": [ + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\nclusterobs_idx (919)\n\nobs_idx (919)\n\n\nclusterobs_idx (919) x feature (2)\n\nobs_idx (919) x feature (2)\n\n\nclusterfloor_effect_features (1)\n\nfloor_effect_features (1)\n\n\n\nlog_radon\n\nlog_radon\n~\nNormal\n\n\n\nlog_radon_observed\n\nlog_radon_observed\n~\nData\n\n\n\nlog_radon->log_radon_observed\n\n\n\n\n\nmu\n\nmu\n~\nDeterministic\n\n\n\nmu->log_radon\n\n\n\n\n\nX_data\n\nX_data\n~\nData\n\n\n\nX_data->mu\n\n\n\n\n\nalpha\n\nalpha\n~\nNormal\n\n\n\nalpha->mu\n\n\n\n\n\nsigma\n\nsigma\n~\nExponential\n\n\n\nsigma->log_radon\n\n\n\n\n\nfloor_effect\n\nfloor_effect\n~\nNormal\n\n\n\nfloor_effect->mu\n\n\n\n\n\n", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_1.to_graphviz()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d02c30b588e778b", + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-13T08:59:00.601737Z", + "start_time": "2024-12-13T08:58:57.993356Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [alpha, floor_effect, sigma]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b50abeac062a48ea8a879cf46af66bd9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 1 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "idata = model_1.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b07a9c5f6774c5a9",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:00.621361Z",
+     "start_time": "2024-12-13T08:59:00.602526Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
alpha1.3610.0281.3051.4110.0000.0004729.03305.01.0
floor_effect[floor]-0.5830.070-0.710-0.4440.0010.0014830.03010.01.0
\n",
+       "
"
+      ],
+      "text/plain": [
+       "                      mean     sd  hdi_3%  hdi_97%  mcse_mean  mcse_sd  \\\n",
+       "alpha                1.361  0.028   1.305    1.411      0.000    0.000   \n",
+       "floor_effect[floor] -0.583  0.070  -0.710   -0.444      0.001    0.001   \n",
+       "\n",
+       "                     ess_bulk  ess_tail  r_hat  \n",
+       "alpha                  4729.0    3305.0    1.0  \n",
+       "floor_effect[floor]    4830.0    3010.0    1.0  "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "az.summary(idata, var_names=[\"alpha\", \"floor_effect\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d712ccf0e172ac3f",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:00.650193Z",
+     "start_time": "2024-12-13T08:59:00.622136Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
              Variable  Expression                            Dimensions                \n",
+       "────────────────────────────────────────────────────────────────────────────────────────\n",
+       "  log_radon_observed =  Data                                  obs_idx[919]              \n",
+       "              X_data =  Data                                  obs_idx[919] × feature[2] \n",
+       "                                                                                        \n",
+       "            alpha_mu ~  Normal(0, 1)                                                    \n",
+       " alpha_county_effect ~  Normal(alpha_mu, 1)                   county[85]                \n",
+       "        floor_effect ~  Normal(0, 1)                          floor_effect_features[1]  \n",
+       "               sigma ~  Exponential(f())                                                \n",
+       "                                                              Parameter count = 88      \n",
+       "                                                                                        \n",
+       "                  mu =  f(alpha_county_effect, floor_effect)  obs_idx[919]              \n",
+       "                                                                                        \n",
+       "           log_radon ~  Normal(mu, sigma)                     obs_idx[919]              \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[1m \u001b[0m\u001b[1m             Variable\u001b[0m\u001b[1m \u001b[0m \u001b[1mExpression                          \u001b[0m\u001b[1m \u001b[0m \u001b[1mDimensions               \u001b[0m\u001b[1m \u001b[0m\n",
+       "────────────────────────────────────────────────────────────────────────────────────────\n",
+       "  log_radon_observed\u001b[1m =\u001b[0m  Data                                  obs_idx[919]              \n",
+       "              X_data\u001b[1m =\u001b[0m  Data                                  obs_idx[919] × feature[2] \n",
+       "                                                                                        \n",
+       "            alpha_mu\u001b[1m ~\u001b[0m  Normal(0, 1)                                                    \n",
+       " alpha_county_effect\u001b[1m ~\u001b[0m  Normal(alpha_mu, 1)                   county[85]                \n",
+       "        floor_effect\u001b[1m ~\u001b[0m  Normal(0, 1)                          floor_effect_features[1]  \n",
+       "               sigma\u001b[1m ~\u001b[0m  Exponential(f())                                                \n",
+       "                                                              \u001b[3mParameter count = 88\u001b[0m      \n",
+       "                                                                                        \n",
+       "                  mu\u001b[1m =\u001b[0m  f(alpha_county_effect, floor_effect)  obs_idx[919]              \n",
+       "                                                                                        \n",
+       "           log_radon\u001b[1m ~\u001b[0m  Normal(mu, sigma)                     obs_idx[919]              \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "county_effect = modular.Intercept(\"alpha\", pooling_columns=\"county\", pooling=\"none\")\n",
+    "model_2 = modular.NormalLikelihood(\n",
+    "    mu=county_effect + floor_effect, sigma=None, data=df, target_col=\"log_radon\"\n",
+    ")\n",
+    "model_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "159d266ea9995c32",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:00.862052Z",
+     "start_time": "2024-12-13T08:59:00.650816Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": "\n\n\n\n\n\n\n\nclusterobs_idx (919)\n\nobs_idx (919)\n\n\nclusterobs_idx (919) x feature (2)\n\nobs_idx (919) x feature (2)\n\n\nclustercounty (85)\n\ncounty (85)\n\n\nclusterfloor_effect_features (1)\n\nfloor_effect_features (1)\n\n\n\nlog_radon\n\nlog_radon\n~\nNormal\n\n\n\nlog_radon_observed\n\nlog_radon_observed\n~\nData\n\n\n\nlog_radon->log_radon_observed\n\n\n\n\n\nmu\n\nmu\n~\nDeterministic\n\n\n\nmu->log_radon\n\n\n\n\n\nX_data\n\nX_data\n~\nData\n\n\n\nX_data->mu\n\n\n\n\n\nalpha_mu\n\nalpha_mu\n~\nNormal\n\n\n\nalpha_county_effect\n\nalpha_county_effect\n~\nNormal\n\n\n\nalpha_mu->alpha_county_effect\n\n\n\n\n\nsigma\n\nsigma\n~\nExponential\n\n\n\nsigma->log_radon\n\n\n\n\n\nalpha_county_effect->mu\n\n\n\n\n\nfloor_effect\n\nfloor_effect\n~\nNormal\n\n\n\nfloor_effect->mu\n\n\n\n\n\n",
+      "text/plain": [
+       ""
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_2.to_graphviz()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "bb2ac8e99471a38a",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:04.529437Z",
+     "start_time": "2024-12-13T08:59:00.863289Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Initializing NUTS using jitter+adapt_diag...\n",
+      "Multiprocess sampling (4 chains in 4 jobs)\n",
+      "NUTS: [alpha_mu, alpha_county_effect, floor_effect, sigma]\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a6e8a9a324624d0ea344c4587c1b60b7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 2 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "idata_2 = model_2.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e21cc7397437e3fc",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:05.153141Z",
+     "start_time": "2024-12-13T08:59:04.530517Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = az.plot_forest(\n",
+    "    idata_2,\n",
+    "    var_names=[\"alpha_county_effect\"],\n",
+    "    r_hat=True,\n",
+    "    combined=True,\n",
+    "    figsize=(6, 18),\n",
+    "    labeller=az.labels.NoVarLabeller(),\n",
+    ")\n",
+    "ax[0].set_ylabel(\"alpha\");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "7a9ce63d361c4039",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:05.223713Z",
+     "start_time": "2024-12-13T08:59:05.154057Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
                     Variable  Expression                                                Dimensions                \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "         log_radon_observed =  Data                                                      obs_idx[919]              \n",
+       "                     X_data =  Data                                                      obs_idx[919] × feature[2] \n",
+       "                                                                                                                   \n",
+       "                      alpha ~  Normal(0, 1)                                                                        \n",
+       "  alpha_county_effect_sigma ~  Gamma(2, f())                                                                       \n",
+       " alpha_county_effect_offset ~  ZeroSumNormal(1, f())                                     county[85]                \n",
+       "               floor_effect ~  Normal(0, 1)                                              floor_effect_features[1]  \n",
+       "                      sigma ~  Exponential(f())                                                                    \n",
+       "                                                                                         Parameter count = 89      \n",
+       "                                                                                                                   \n",
+       "        alpha_county_effect =  f(alpha_county_effect_offset, alpha,                      county[85]                \n",
+       "                               alpha_county_effect_sigma)                                                          \n",
+       "                         mu =  f(floor_effect, alpha_county_effect_offset, alpha,        obs_idx[919]              \n",
+       "                               alpha_county_effect_sigma)                                                          \n",
+       "                                                                                                                   \n",
+       "                  log_radon ~  Normal(mu, sigma)                                         obs_idx[919]              \n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\u001b[1m \u001b[0m\u001b[1m                    Variable\u001b[0m\u001b[1m \u001b[0m \u001b[1mExpression                                              \u001b[0m\u001b[1m \u001b[0m \u001b[1mDimensions               \u001b[0m\u001b[1m \u001b[0m\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "         log_radon_observed\u001b[1m =\u001b[0m  Data                                                      obs_idx[919]              \n",
+       "                     X_data\u001b[1m =\u001b[0m  Data                                                      obs_idx[919] × feature[2] \n",
+       "                                                                                                                   \n",
+       "                      alpha\u001b[1m ~\u001b[0m  Normal(0, 1)                                                                        \n",
+       "  alpha_county_effect_sigma\u001b[1m ~\u001b[0m  Gamma(2, f())                                                                       \n",
+       " alpha_county_effect_offset\u001b[1m ~\u001b[0m  ZeroSumNormal(1, f())                                     county[85]                \n",
+       "               floor_effect\u001b[1m ~\u001b[0m  Normal(0, 1)                                              floor_effect_features[1]  \n",
+       "                      sigma\u001b[1m ~\u001b[0m  Exponential(f())                                                                    \n",
+       "                                                                                         \u001b[3mParameter count = 89\u001b[0m      \n",
+       "                                                                                                                   \n",
+       "        alpha_county_effect\u001b[1m =\u001b[0m  f(alpha_county_effect_offset, alpha,                      county[85]                \n",
+       "                               alpha_county_effect_sigma)                                                          \n",
+       "                         mu\u001b[1m =\u001b[0m  f(floor_effect, alpha_county_effect_offset, alpha,        obs_idx[919]              \n",
+       "                               alpha_county_effect_sigma)                                                          \n",
+       "                                                                                                                   \n",
+       "                  log_radon\u001b[1m ~\u001b[0m  Normal(mu, sigma)                                         obs_idx[919]              \n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "county_effect.pooling = \"partial\"\n",
+    "\n",
+    "model_3 = modular.NormalLikelihood(\n",
+    "    mu=county_effect + floor_effect, sigma=None, data=df, target_col=\"log_radon\"\n",
+    ")\n",
+    "model_3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "3c27cd322fd7e2cf",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:05.544073Z",
+     "start_time": "2024-12-13T08:59:05.226715Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": "\n\n\n\n\n\n\n\nclusterobs_idx (919)\n\nobs_idx (919)\n\n\nclusterobs_idx (919) x feature (2)\n\nobs_idx (919) x feature (2)\n\n\nclustercounty (85)\n\ncounty (85)\n\n\nclusterfloor_effect_features (1)\n\nfloor_effect_features (1)\n\n\n\nlog_radon\n\nlog_radon\n~\nNormal\n\n\n\nlog_radon_observed\n\nlog_radon_observed\n~\nData\n\n\n\nlog_radon->log_radon_observed\n\n\n\n\n\nmu\n\nmu\n~\nDeterministic\n\n\n\nmu->log_radon\n\n\n\n\n\nX_data\n\nX_data\n~\nData\n\n\n\nX_data->mu\n\n\n\n\n\nalpha\n\nalpha\n~\nNormal\n\n\n\nalpha_county_effect\n\nalpha_county_effect\n~\nDeterministic\n\n\n\nalpha->alpha_county_effect\n\n\n\n\n\nalpha_county_effect_sigma\n\nalpha_county_effect_sigma\n~\nGamma\n\n\n\nalpha_county_effect_sigma->alpha_county_effect\n\n\n\n\n\nsigma\n\nsigma\n~\nExponential\n\n\n\nsigma->log_radon\n\n\n\n\n\nalpha_county_effect->mu\n\n\n\n\n\nalpha_county_effect_offset\n\nalpha_county_effect_offset\n~\nZeroSumNormal\n\n\n\nalpha_county_effect_offset->alpha_county_effect\n\n\n\n\n\nfloor_effect\n\nfloor_effect\n~\nNormal\n\n\n\nfloor_effect->mu\n\n\n\n\n\n",
+      "text/plain": [
+       ""
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_3.to_graphviz()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "59fdd301f6c5f877",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:09.809969Z",
+     "start_time": "2024-12-13T08:59:05.545656Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Initializing NUTS using jitter+adapt_diag...\n",
+      "Multiprocess sampling (4 chains in 4 jobs)\n",
+      "NUTS: [alpha, alpha_county_effect_sigma, alpha_county_effect_offset, floor_effect, sigma]\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b35ba98357524fc0be9ea00ec68f95a7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 3 seconds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "idata_3 = model_3.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "38f408e4c41e95cd",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:09.902843Z",
+     "start_time": "2024-12-13T08:59:09.811167Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 8), dpi=77)\n",
+    "alpha_unpooled = idata_2.posterior.alpha_county_effect.mean(dim=[\"chain\", \"draw\"]).values\n",
+    "alpha_pooled = idata_3.posterior.alpha_county_effect.mean(dim=[\"chain\", \"draw\"]).values\n",
+    "\n",
+    "ax.scatter(np.zeros_like(alpha_unpooled), alpha_unpooled)\n",
+    "ax.scatter(np.ones_like(alpha_pooled), alpha_pooled)\n",
+    "\n",
+    "for y1, y2 in zip(alpha_unpooled, alpha_pooled):\n",
+    "    ax.arrow(0, y1, 1, y2 - y1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1bad99684b210e03",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-13T08:59:09.905286Z",
+     "start_time": "2024-12-13T08:59:09.903807Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}