marginaleffects 0.6.0__tar.gz → 0.6.2__tar.gz

{marginaleffects-0.6.0 → marginaleffects-0.6.2}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: marginaleffects
-Version: 0.6.0
+Version: 0.6.2
 Summary: Predictions, counterfactual comparisons, slopes, and hypothesis tests for statistical models.
 License-Expression: GPL-3.0-or-later
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: formulaic>=1.0.2
-Requires-Dist: jax>=0.4.0
 Requires-Dist: narwhals>=1.34.0
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: patsy>=1.0.1
@@ -22,7 +21,6 @@ Requires-Dist: linearmodels>=6.1; extra == "test"
 Requires-Dist: pandas>=2.2.2; extra == "test"
 Requires-Dist: pre-commit>=4.2.0; extra == "test"
 Requires-Dist: numba; extra == "test"
-Requires-Dist: pyarrow>=17.0.0; extra == "test"
 Requires-Dist: pyfixest>=0.28.0; extra == "test"
 Requires-Dist: statsmodels>=0.14.0; extra == "test"
 Requires-Dist: scikit-learn; extra == "test"

marginaleffects-0.6.2/benchmarks/benchmark_inference.py

@@ -0,0 +1,39 @@
+"""End-to-end inference benchmark across observations and coefficient counts.
+
+Run with: ``uv run --all-extras python benchmarks/benchmark_inference.py``.
+"""
+
+import time
+
+import numpy as np
+import polars as pl
+import statsmodels.api as sm
+
+from marginaleffects import avg_comparisons, avg_predictions, comparisons, predictions
+
+
+def make_model(n_obs, n_coef, seed=42):
+    rng = np.random.default_rng(seed)
+    X = rng.normal(size=(n_obs, n_coef))
+    beta = rng.normal(size=n_coef)
+    data = pl.DataFrame({f"x{i}": X[:, i] for i in range(n_coef)})
+    data = data.with_columns(y=pl.Series(X @ beta + rng.normal(size=n_obs)))
+    formula = "y ~ " + " + ".join(f"x{i}" for i in range(n_coef))
+    return sm.OLS.from_formula(formula, data.to_pandas()).fit()
+
+
+def elapsed(call):
+    start = time.perf_counter()
+    call()
+    return time.perf_counter() - start
+
+
+if __name__ == "__main__":
+    cases = (predictions, avg_predictions, comparisons, avg_comparisons)
+    for n_obs in (100, 1_000, 10_000):
+        for n_coef in (5, 25, 100):
+            model = make_model(n_obs, n_coef)
+            for func in cases:
+                kwargs = {"variables": "x0"} if "comparisons" in func.__name__ else {}
+                duration = elapsed(lambda: func(model, **kwargs))
+                print(f"{func.__name__:18} n={n_obs:5} p={n_coef:3}: {duration:.4f}s")

{marginaleffects-0.6.0 → marginaleffects-0.6.2}/marginaleffects/__init__.py

@@ -1,7 +1,5 @@
-from importlib import import_module
-import importlib.util
 import sys
-
+from importlib import import_module
 
 _EXPORTS = {
     "avg_comparisons": ("marginaleffects.comparisons", "avg_comparisons"),
@@ -20,14 +18,12 @@ _EXPORTS = {
     "fit_linearmodels": ("marginaleffects.linearmodels.model", "fit_linearmodels"),
     "get_dataset": ("marginaleffects.datasets", "get_dataset"),
     "MarginaleffectsResult": ("marginaleffects.classes", "MarginaleffectsResult"),
-    "autodiff": ("marginaleffects.settings", "autodiff"),
-    "set_autodiff": ("marginaleffects.settings", "set_autodiff"),
-    "get_autodiff": ("marginaleffects.settings", "get_autodiff"),
+    "vcovUnconditional": (
+        "marginaleffects.inference.unconditional",
+        "vcovUnconditional",
+    ),
 }
 
-if importlib.util.find_spec("jax") is not None:
-    _EXPORTS["autodiff_module"] = ("marginaleffects.autodiff", None)
-
 __all__ = list(_EXPORTS.keys())
 
 

marginaleffects-0.6.2/marginaleffects/by.py

@@ -0,0 +1,297 @@
+import warnings
+
+import polars as pl
+
+from .planning import AggGroup
+from .sanitize.by import by_frame_keys, by_is_frame
+
+BY_FRAME_COVERAGE_WARNING = (
+    "The `by` data frame does not cover all combinations of response levels "
+    "and/or predictors. Some estimates will not be included in the aggregation."
+)
+
+
+def _mean_expr() -> pl.Expr:
+    """Unweighted group mean, dropping missing estimates as R's `na.rm` does.
+
+    Polars propagates NaN through `mean()` while skipping nulls. Treating the
+    two alike keeps this displayed estimate identical to the one the plan
+    replay recomputes, which the replay baseline check requires.
+    """
+    return pl.col("estimate").fill_nan(None).mean().alias("estimate")
+
+
+def _weighted_mean_expr(wts: str) -> pl.Expr:
+    """Weighted group mean under R's missing-value rules.
+
+    A missing estimate zeroes both itself and its weight, so it leaves the
+    aggregate untouched. A zero weight blanks the estimate it multiplies,
+    because `0 * Inf` is NaN and would otherwise poison the whole group. A
+    missing weight propagates: dropping the row it belongs to would silently
+    report a different estimand than the one requested.
+    """
+    est = pl.col("estimate")
+    w = pl.col(wts).cast(pl.Float64).fill_null(float("nan"))
+    missing = est.is_null() | est.is_nan()
+    numerator = pl.when(missing | (w == 0)).then(0.0).otherwise(est * w).sum()
+    denominator = pl.when(missing).then(0.0).otherwise(w).sum()
+    return (numerator / denominator).alias("estimate")
+
+
+def harmonize_by_types(estimates: pl.DataFrame, by: pl.DataFrame) -> pl.DataFrame:
+    """Reconcile join-key dtypes between the estimates and a `by` data frame.
+
+    A label table is usually typed by hand, so its keys routinely disagree with
+    the estimates on numeric-versus-string. Joining on mismatched dtypes finds
+    nothing and would silently drop every row, so the keys are cast to the
+    estimates' side before the join rather than after it fails.
+    """
+    casts = []
+    for column in by.columns:
+        if column == "by" or column not in estimates.columns:
+            continue
+        target = estimates[column].dtype
+        if by[column].dtype == target:
+            continue
+        if target.is_numeric() or target in (pl.String, pl.Utf8):
+            casts.append(pl.col(column).cast(target, strict=False))
+        else:
+            casts.append(pl.col(column).cast(pl.String).cast(target, strict=False))
+    return by.with_columns(casts) if casts else by
+
+
+def attach_by_labels(estimates: pl.DataFrame, by: pl.DataFrame, verbose: bool = True):
+    """Left-join a `by` data frame's labels onto the estimates.
+
+    Returns the labelled estimates and a boolean mask of the rows the label
+    table covers. Uncovered rows are dropped rather than aggregated under a
+    missing label, matching R, and the caller is warned because a partial
+    label table is far more often a typo than an intent.
+    """
+    keys = [x for x in by_frame_keys(by) if x in estimates.columns]
+    if not keys:
+        raise ValueError(
+            "None of the columns in the `by` data frame match the estimates. "
+            f"Available columns: {', '.join(estimates.columns)}."
+        )
+    labels = harmonize_by_types(estimates, by.select([*keys, "by"])).unique(subset=keys)
+    if "by" in estimates.columns:
+        estimates = estimates.drop("by")
+    out = estimates.join(labels, on=keys, how="left")
+    keep = out["by"].is_not_null()
+    if verbose and not keep.all():
+        warnings.warn(BY_FRAME_COVERAGE_WARNING, UserWarning, stacklevel=2)
+    return out, keep
+
+
+def get_by(model, estimand, newdata, by=None, wts=None):
+    out, _ = _get_by_internal(
+        model=model,
+        estimand=estimand,
+        newdata=newdata,
+        by=by,
+        wts=wts,
+    )
+    return out
+
+
+def get_by_plan(model, estimand, newdata, by=None, wts=None):
+    out, agg_groups = _get_by_internal(
+        model=model,
+        estimand=estimand,
+        newdata=newdata,
+        by=by,
+        wts=wts,
+        return_plan_groups=True,
+    )
+    return out, agg_groups
+
+
+def _get_by_internal(
+    model,
+    estimand,
+    newdata,
+    by=None,
+    wts=None,
+    return_plan_groups: bool = False,
+) -> tuple[pl.DataFrame, list[AggGroup] | None]:
+    # for predictions
+    if (
+        isinstance(by, list)
+        and len(by) == 1
+        and by[0] == "group"
+        and "group" not in estimand.columns
+    ):
+        by = True
+
+    agg_groups: list[AggGroup] | None = None
+
+    if by_is_frame(by):
+        return _get_by_frame(
+            estimand=estimand,
+            newdata=newdata,
+            by=by,
+            wts=wts,
+            return_plan_groups=return_plan_groups,
+        )
+
+    if by is True:
+        # A grand mean must respect user weights exactly like the named-group
+        # path below does; ignoring `wts` here would silently report a
+        # different estimand than the one requested, with a Jacobian to match.
+        w_arr = None
+        if wts is not None:
+            tmp = estimand
+            if (
+                wts not in tmp.columns
+                and "rowid" in tmp.columns
+                and "rowid" in newdata.columns
+            ):
+                # The recorded weights must line up with the Jacobian rows,
+                # which follow the estimand's row order. A join does not
+                # promise to preserve that order, so carry an explicit
+                # position column through it and restore the order afterward.
+                tmp = tmp.with_columns(
+                    pl.Series(
+                        "_marginaleffects_wpos",
+                        range(tmp.height),
+                        dtype=pl.Int32,
+                    )
+                )
+                tmp = tmp.join(newdata.select(["rowid", wts]), on="rowid", how="left")
+                tmp = tmp.sort("_marginaleffects_wpos").drop("_marginaleffects_wpos")
+            if wts not in tmp.columns:
+                raise ValueError(f"Weights column '{wts}' not found for aggregation.")
+            if tmp.height != estimand.height:
+                raise ValueError(
+                    "Joining the weights column changed the number of rows; "
+                    "`newdata` has duplicated `rowid` values."
+                )
+            if tmp[wts].null_count() > 0:
+                raise ValueError(
+                    f"Weights column '{wts}' has missing values after joining "
+                    "on `rowid`."
+                )
+            result = tmp.select(_weighted_mean_expr(wts))
+            w_arr = tmp[wts].cast(pl.Float64).to_numpy()
+        else:
+            result = estimand.select(_mean_expr())
+        if return_plan_groups:
+            agg_groups = [
+                AggGroup(idx=pl.Series(range(estimand.height)).to_numpy(), w=w_arr)
+            ]
+        return result, agg_groups
+    elif by is False:
+        return estimand, agg_groups
+
+    if "group" in estimand.columns:
+        by = ["group"] + by
+
+    if return_plan_groups:
+        estimand = estimand.with_columns(
+            pl.Series("_marginaleffects_pos", range(estimand.height), dtype=pl.Int32)
+        )
+
+    if "rowid" in estimand.columns and "rowid" in newdata.columns:
+        out = estimand.join(newdata, on="rowid", how="left")
+    else:
+        out = pl.DataFrame({"estimate": estimand["estimate"]})
+
+    by = list(dict.fromkeys(x for x in by if x in out.columns))
+
+    if isinstance(by, list) and len(by) == 0:
+        return out, agg_groups
+
+    agg_exprs: list[pl.Expr] = []
+    if wts is None:
+        agg_exprs.append(_mean_expr())
+    else:
+        agg_exprs.append(_weighted_mean_expr(wts))
+    if return_plan_groups and "_marginaleffects_pos" in out.columns:
+        agg_exprs.append(pl.col("_marginaleffects_pos").alias("_positions"))
+        if wts is not None:
+            agg_exprs.append(pl.col(wts).cast(pl.Float64).alias("_plan_weights"))
+
+    out = out.group_by(by, maintain_order=True).agg(agg_exprs)
+
+    # Sort by 'by' columns ONLY if they are Enum type to ensure consistent categorical ordering
+    # For Enum columns, sort() respects the enum order (not lexical order)
+    # For other types (strings, numbers), maintain the group_by order to preserve existing behavior
+    if isinstance(by, str):
+        by_cols = [by]
+    else:
+        by_cols = list(by)
+
+    should_sort = any(
+        out[col].dtype == pl.Enum for col in by_cols if col in out.columns
+    )
+    if should_sort:
+        out = out.sort(by)
+
+    if return_plan_groups and "_positions" in out.columns:
+        weights = (
+            out["_plan_weights"].to_list()
+            if wts is not None and "_plan_weights" in out.columns
+            else None
+        )
+        agg_groups = []
+        for i, positions in enumerate(out["_positions"].to_list()):
+            w = None if weights is None else pl.Series(weights[i]).to_numpy()
+            agg_groups.append(AggGroup(idx=pl.Series(positions).to_numpy(), w=w))
+        drop_cols = ["_positions"]
+        if "_plan_weights" in out.columns:
+            drop_cols.append("_plan_weights")
+        out = out.drop(drop_cols)
+
+    return out, agg_groups
+
+
+def _get_by_frame(estimand, newdata, by, wts, return_plan_groups: bool):
+    """Aggregate estimates under labels supplied as a `by` data frame.
+
+    The label table can map several predictor combinations onto one label, so
+    grouping happens on the joined label rather than on the estimates' own
+    columns. Row positions are recorded before the join because the plan's
+    prediction vector is indexed by the *unfiltered* estimand order, which
+    dropping uncovered rows would otherwise shift.
+    """
+    position = "_marginaleffects_pos"
+    estimand = estimand.with_columns(
+        pl.Series(position, range(estimand.height), dtype=pl.Int64)
+    )
+
+    keys = by_frame_keys(by)
+    missing = [x for x in keys if x not in estimand.columns]
+    if missing and "rowid" in estimand.columns and "rowid" in newdata.columns:
+        payload = [x for x in missing if x in newdata.columns]
+        if payload:
+            estimand = estimand.join(
+                newdata.select(["rowid", *payload]), on="rowid", how="left"
+            )
+
+    labelled, keep = attach_by_labels(estimand, by)
+    labelled = labelled.filter(keep)
+
+    group_cols = [x for x in ("term", "by") if x in labelled.columns]
+    weighted = wts is not None and wts in labelled.columns
+    agg_exprs = [_weighted_mean_expr(wts) if weighted else _mean_expr()]
+    if return_plan_groups:
+        agg_exprs.append(pl.col(position).alias("_positions"))
+        if weighted:
+            agg_exprs.append(pl.col(wts).cast(pl.Float64).alias("_plan_weights"))
+
+    out = labelled.group_by(group_cols, maintain_order=True).agg(agg_exprs)
+
+    agg_groups = None
+    if return_plan_groups:
+        weights = out["_plan_weights"].to_list() if weighted else None
+        agg_groups = [
+            AggGroup(
+                idx=pl.Series(positions).to_numpy(),
+                w=None if weights is None else pl.Series(weights[i]).to_numpy(),
+            )
+            for i, positions in enumerate(out["_positions"].to_list())
+        ]
+        out = out.drop([x for x in ("_positions", "_plan_weights") if x in out.columns])
+
+    return out.select([*group_cols, "estimate"]), agg_groups

{marginaleffects-0.6.0 → marginaleffects-0.6.2}/marginaleffects/classes/__init__.py

@@ -1,18 +1,20 @@
-from .result import MarginaleffectsResult, MarginaleffectsDataFrame
+from .result import MarginaleffectsDataFrame, MarginaleffectsResult
 
 __all__ = [
-    "MarginaleffectsResult",
     "MarginaleffectsDataFrame",
+    "MarginaleffectsResult",
     "ModelAbstract",
+    "ModelAdapter",
     "ModelVault",
 ]
 
 
 def __getattr__(name):
-    if name in ("ModelAbstract", "ModelVault"):
-        from .model import ModelAbstract, ModelVault
+    if name in ("ModelAbstract", "ModelAdapter", "ModelVault"):
+        from .model import ModelAbstract, ModelAdapter, ModelVault
 
         globals()["ModelAbstract"] = ModelAbstract
+        globals()["ModelAdapter"] = ModelAdapter
         globals()["ModelVault"] = ModelVault
-        return ModelAbstract if name == "ModelAbstract" else ModelVault
+        return globals()[name]
     raise AttributeError(f"module 'marginaleffects.classes' has no attribute {name!r}")

{marginaleffects-0.6.0 → marginaleffects-0.6.2}/marginaleffects/classes/model.py

@@ -1,36 +1,50 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Protocol, runtime_checkable
 
 import numpy as np
 import polars as pl
 
-from ..sanitize.validation import ModelValidation
 from .. import formula as fml
+from ..sanitize.validation import ModelValidation
 
 
 @dataclass
 class ModelVault:
     """Typed container for model metadata shared across all adapters."""
 
-    coef: Optional[np.ndarray] = None
-    coefnames: Optional[np.ndarray] = None
-    formula: Optional[str] = None
+    coef: np.ndarray | None = None
+    coefnames: np.ndarray | None = None
+    formula: str | None = None
     formula_engine: str = "formulaic"
-    modeldata: Optional[pl.DataFrame] = None
+    modeldata: pl.DataFrame | None = None
     package: str = "unknown"
-    vcov: Optional[np.ndarray] = None
-    variables_type: Dict[str, str] = field(default_factory=dict)
-    variable_names: Optional[List[str]] = None
-    engine_running: Optional[Any] = None
+    vcov: np.ndarray | None = None
+    variables_type: dict[str, str] = field(default_factory=dict)
+    variable_names: list[str] | None = None
+    engine_running: Any | None = None
     # statsmodels-specific
-    design_info_patsy: Optional[Any] = None
-    pandas_categorical_orders: Dict[str, list] = field(default_factory=dict)
+    design_info_patsy: Any | None = None
+    pandas_categorical_orders: dict[str, list] = field(default_factory=dict)
     # sklearn-specific
-    model_spec: Optional[Any] = None
-    original_columns: Optional[List[str]] = None
+    model_spec: Any | None = None
+    original_columns: list[str] | None = None
     # linearmodels-specific
-    multiindex: Optional[List[str]] = None
+    multiindex: list[str] | None = None
+
+
+@runtime_checkable
+class ModelAdapter(Protocol):
+    """Explicit contract consumed by marginaleffects estimation code."""
+
+    def get_modeldata(self) -> pl.DataFrame: ...
+    def get_vcov(self, vcov=True) -> np.ndarray | None: ...
+    def get_coef(self) -> np.ndarray: ...
+    def get_coefnames(self) -> np.ndarray: ...
+    def get_formula(self): ...
+    def get_exog(self, newdata: pl.DataFrame): ...
+    def get_predict(self, params: np.ndarray, newdata) -> pl.DataFrame: ...
+    def get_df(self) -> float: ...
 
 
 class ModelAbstract(ModelValidation, ABC):
@@ -39,22 +53,22 @@ class ModelAbstract(ModelValidation, ABC):
         self.vault = vault
         self.validation()
 
-    def get_modeldata(self) -> Optional[pl.DataFrame]:
+    def get_modeldata(self) -> pl.DataFrame | None:
         return self.vault.modeldata
 
-    def get_vcov(self, vcov=False) -> Optional[np.ndarray]:
+    def get_vcov(self, vcov=False) -> np.ndarray | None:
         return self.vault.vcov
 
-    def get_coef(self) -> Optional[np.ndarray]:
+    def get_coef(self) -> np.ndarray | None:
         return self.vault.coef
 
-    def get_coefnames(self) -> Optional[np.ndarray]:
+    def get_coefnames(self) -> np.ndarray | None:
         return self.vault.coefnames
 
-    def get_engine_running(self) -> Optional[Any]:
+    def get_engine_running(self) -> Any | None:
         return self.vault.engine_running
 
-    def get_formula(self) -> Optional[str]:
+    def get_formula(self) -> str | None:
         return self.vault.formula
 
     def get_formula_engine(self) -> str:
@@ -63,7 +77,7 @@ class ModelAbstract(ModelValidation, ABC):
     def get_package(self) -> str:
         return self.vault.package
 
-    def get_variable_type(self, name=None) -> Dict[str, str]:
+    def get_variable_type(self, name=None) -> dict[str, str]:
         variables = self.vault.variables_type
         if isinstance(name, str) and name in variables:
             return variables[name]
@@ -73,7 +87,7 @@ class ModelAbstract(ModelValidation, ABC):
     def set_variable_type(self, name, value):
         self.vault.variables_type[name] = value
 
-    def find_variables(self) -> Optional[List[str]]:
+    def find_variables(self) -> list[str] | None:
         if self.vault.variable_names is not None:
             return self.vault.variable_names
 
@@ -87,14 +101,14 @@ class ModelAbstract(ModelValidation, ABC):
 
         return out
 
-    def find_response(self) -> Optional[str]:
+    def find_response(self) -> str | None:
         vars = self.find_variables()
         if vars is None:
             return None
         else:
             return vars[0]
 
-    def find_predictors(self) -> Optional[List[str]]:
+    def find_predictors(self) -> list[str] | None:
         vars = self.find_variables()
         if vars is None:
             return None
@@ -127,13 +141,25 @@ class ModelAbstract(ModelValidation, ABC):
     def get_predict(self, params: np.ndarray, newdata) -> pl.DataFrame:
         pass
 
-    def get_autodiff_args(self):
-        return None
+    def get_analytic_args(self):
+        """Return adapter metadata needed by the analytic Jacobian engine."""
+        return
+
+    def get_link_functions(self):
+        """Return inverse-link and derivative callables for response predictions."""
+        return
+
+    def get_exog_names(self, value):
+        """Return design-column names, or ``None`` when they are unavailable."""
+        design_info = getattr(value, "design_info", None)
+        columns = getattr(design_info, "column_names", None)
+        if columns is None:
+            columns = getattr(value, "columns", None)
+        return None if columns is None else list(columns)
+
+    def get_df(self) -> float:
+        return np.inf
 
-    def __getattr__(self, name: str) -> Any:
-        """Forward attribute access to the underlying fitted model."""
-        try:
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            # Forward to the wrapped model
-            return getattr(self.model, name)
+    def get_fitted_model(self) -> Any:
+        """Return the wrapped engine object for adapter-specific integrations."""
+        return self.model

{marginaleffects-0.6.0 → marginaleffects-0.6.2}/marginaleffects/classes/result.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import warnings
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, Iterator, Optional
+from typing import Any
 
 import polars as pl
 
@@ -10,7 +11,7 @@ import polars as pl
 def _default_mapping(
     data: pl.DataFrame,
     datagrid_explicit: Iterable[str],
-) -> Dict[str, str]:
+) -> dict[str, str]:
     datagrid_explicit = list(datagrid_explicit)
     datagrid_map = dict(zip(datagrid_explicit, datagrid_explicit))
     contrast_columns = {
@@ -18,7 +19,7 @@ def _default_mapping(
         for col in data.columns
         if col.startswith("contrast_")
     }
-    mapping: Dict[str, str] = {
+    mapping: dict[str, str] = {
         "term": "Term",
         "group": "Group",
         **datagrid_map,
@@ -40,12 +41,13 @@ def _default_mapping(
 
 @dataclass
 class _Metadata:
-    by: Optional[Any]
+    by: Any | None
     conf_level: float
-    jacobian: Optional[Any]
+    jacobian: Any | None
+    jacobian_method: str | None
     datagrid_explicit: Iterable[str]
     print_head: str
-    mapping: Dict[str, str]
+    mapping: dict[str, str]
 
 
 class MarginaleffectsResult:
@@ -58,11 +60,12 @@ class MarginaleffectsResult:
         self,
         data: pl.DataFrame,
         *,
-        by: Optional[Any] = None,
+        by: Any | None = None,
         conf_level: float = 0.95,
-        jacobian: Optional[Any] = None,
-        newdata: Optional[Any] = None,
-        mapping: Optional[Dict[str, str]] = None,
+        jacobian: Any | None = None,
+        jacobian_method: str | None = None,
+        newdata: Any | None = None,
+        mapping: dict[str, str] | None = None,
         print_head: str = "",
     ) -> None:
         if not isinstance(data, pl.DataFrame):
@@ -82,6 +85,7 @@ class MarginaleffectsResult:
             by=by,
             conf_level=conf_level,
             jacobian=jacobian,
+            jacobian_method=jacobian_method,
             datagrid_explicit=list(datagrid_explicit),
             print_head=print_head,
             mapping=final_mapping,
@@ -96,7 +100,7 @@ class MarginaleffectsResult:
         return self._data
 
     @property
-    def by(self) -> Optional[Any]:
+    def by(self) -> Any | None:
         return self._meta.by
 
     @property
@@ -104,9 +108,14 @@ class MarginaleffectsResult:
         return self._meta.conf_level
 
     @property
-    def jacobian(self) -> Optional[Any]:
+    def jacobian(self) -> Any | None:
         return self._meta.jacobian
 
+    @property
+    def jacobian_method(self) -> str | None:
+        """Method used to differentiate the coefficient-to-estimand map."""
+        return self._meta.jacobian_method
+
     @property
     def datagrid_explicit(self) -> Iterable[str]:
         return self._meta.datagrid_explicit
@@ -205,6 +214,7 @@ class MarginaleffectsResult:
                         by=self.by,
                         conf_level=self.conf_level,
                         jacobian=self.jacobian,
+                        jacobian_method=self.jacobian_method,
                         mapping=self._meta.mapping.copy(),
                         print_head=self._meta.print_head,
                     )