econml.dml._rlearner

R Learner 是一种用于在不存在未观测混淆变量的情况下估计条件平均处理效应的灵活非参数模型的方法。该方法基于 Neyman 正交思想，并估计一个 CATE，其均方误差对辅助子模型的估计误差具有鲁棒性，这些辅助子模型也需要从数据中估计得到。

  1. 结果或回归模型

  2. 处理变量或倾向性或策略或日志策略模型

参考文献

Xinkun Nie, Stefan Wager (2017). Quasi-Oracle Estimation of Heterogeneous Treatment Effects.

https://arxiv.org/abs/1712.04912

Dylan Foster, Vasilis Syrgkanis (2019). Orthogonal Statistical Learning.

ACM 学习理论会议. https://arxiv.org/abs/1901.09036

Chernozhukov et al. (2017). Double/debiased machine learning for treatment and structural parameters.

计量经济学杂志. https://arxiv.org/abs/1608.00060

类

_RLearner(*, discrete_outcome, ...[, ...])

对处理变量和结果进行残差化，并运行残差对残差回归的 CATE 学习器的基类。
class econml.dml._rlearner._RLearner(*, discrete_outcome, discrete_treatment, treatment_featurizer, categories, cv, random_state, mc_iters=None, mc_agg='mean', allow_missing=False, use_ray=False, ray_remote_func_options=None)[source]

基类: econml._ortho_learner._OrthoLearner

对处理变量和结果进行残差化，并运行残差对残差回归的 CATE 学习器的基类。该估计器是 _OrthoLearner 估计器的一个特例，因此它遵循两阶段过程：第一阶段以交叉拟合的方式估计一组“讨厌”函数（nuisance functions），第二阶段估计 CATE 模型。有关此两阶段过程的描述，请参阅 _OrthoLearner 的文档。

在此估计器中，CATE 通过使用以下估计方程进行估计

\[Y - \E[Y | X, W] = \Theta(X) \cdot (T - \E[T | X, W]) + \epsilon\]

因此，如果在第一阶段估计“讨厌”函数 \(q(X, W) = \E[Y | X, W]\) 和 \(f(X, W)=\E[T | X, W]\)，则可以通过运行回归、最小化残差对残差平方损失来估计每个处理变量 t 的最终阶段 CATE

\[\hat{\theta} = \arg\min_{\Theta} \E_n\left[ (\tilde{Y} - \Theta(X) \cdot \tilde{T})^2 \right]\]

其中 \(\tilde{Y}=Y - \E[Y | X, W]\) 和 \(\tilde{T}=T-\E[T | X, W]\) 表示残差结果和残差处理变量。

参数

  • discrete_outcome (bool) – 结果是否应被视为二元的

  • discrete_treatment (bool) – 处理变量值是否应被视为分类变量，而不是连续变量

  • treatment_featurizer (transformer 或 None) – 必须支持 fit_transform 和 transform 方法。用于在最终 CATE 回归中创建组合处理变量。最终的 CATE 将在 featurizer.fit_transform(T) 的输出上进行训练。如果 featurizer=None，则 CATE 在 T 上进行训练。

  • categories (‘auto’ 或 list) – 在编码离散处理变量时使用的类别（或 ‘auto’ 表示使用唯一的排序值）。第一个类别将被视为对照处理变量。

  • cv (int, 交叉验证生成器或可迭代对象) – 确定交叉验证的分割策略。cv 可能的输入包括

    • None，使用默认的 3 折交叉验证，

    • 整数，指定折数。

    • CV 分割器

    • 一个可迭代对象，生成 (训练集, 测试集) 分割（作为索引数组）。

    对于整数/None 输入，如果处理变量是离散的，则使用 StratifiedKFold；否则，使用 KFold（两种情况都会随机打乱）。

    除非使用可迭代对象，否则我们调用 split(concat[W, X], T) 来生成分割。如果所有 W, X 都是 None，则我们调用 split(ones((T.shape[0], 1)), T)。

  • random_state (int, RandomState 实例或 None) – 如果是 int，则 random_state 是随机数生成器使用的种子；如果是 RandomState 实例，则 random_state 是随机数生成器；如果是 None，则随机数生成器是 RandomState 实例，由 np.random 使用。

  • mc_iters (int, 可选) – 重新运行第一阶段模型的次数，以减少“讨厌”项的方差。

  • mc_agg ({‘mean’, ‘median’}, 默认 ‘mean’) – 如何在 mc_iters 次蒙特卡洛交叉拟合迭代中聚合每个样本的“讨厌”项值。

  • allow_missing (bool) – 是否允许 X, W 中存在缺失值。如果为 True，则需要提供能够处理缺失值的“讨厌”模型。

  • use_ray (bool, 默认 False) – 是否使用 Ray 加速交叉拟合步骤。

  • ray_remote_func_options (dict, 可选) – 传递给 ray.remote 函数装饰器的选项。更多信息请参见 https://docs.rayai.org.cn/en/latest/ray-core/api/doc/ray.remote.html

示例

下面的示例代码在 _RLearner 类之上实现了一个非常简单的双重机器学习方法版本，仅作演示。有关 Double Machine Learning 子类的更详细实现，请参阅 DML 及其子类

import numpy as np
from sklearn.linear_model import LinearRegression
from econml.dml._rlearner import _RLearner
from econml.sklearn_extensions.model_selection import SingleModelSelector
from sklearn.base import clone
class ModelFirst:
    def __init__(self, model):
        self._model = clone(model, safe=False)
    def fit(self, X, W, Y, sample_weight=None):
        self._model.fit(np.hstack([X, W]), Y)
        return self
    def predict(self, X, W):
        return self._model.predict(np.hstack([X, W]))
class ModelSelector(SingleModelSelector):
    def __init__(self, model):
        self._model = ModelFirst(model)
    def train(self, is_selecting, folds, X, W, Y, sample_weight=None):
        self._model.fit(X, W, Y, sample_weight=sample_weight)
        return self
    @property
    def best_model(self):
        return self._model
    @property
    def best_score(self):
        return 0
class ModelFinal:
    def fit(self, X, T, T_res, Y_res, sample_weight=None, freq_weight=None, sample_var=None):
        self.model = LinearRegression(fit_intercept=False).fit(X * T_res.reshape(-1, 1),
                                                               Y_res)
        return self
    def predict(self, X):
        return self.model.predict(X)
class RLearner(_RLearner):
    def _gen_model_y(self):
        return ModelSelector(LinearRegression())
    def _gen_model_t(self):
        return ModelSelector(LinearRegression())
    def _gen_rlearner_model_final(self):
        return ModelFinal()
np.random.seed(123)
X = np.random.normal(size=(1000, 3))
y = X[:, 0] + X[:, 1] + np.random.normal(0, 0.01, size=(1000,))
est = RLearner(cv=2, discrete_outcome=False, discrete_treatment=False,
               treatment_featurizer=None, categories='auto', random_state=None)
est.fit(y, X[:, 0], X=np.ones((X.shape[0], 1)), W=X[:, 1:])

>>> est.const_marginal_effect(np.ones((1,1)))
array([0.999631...])
>>> est.effect(np.ones((1,1)), T0=0, T1=10)
array([9.996314...])
>>> est.score(y, X[:, 0], X=np.ones((X.shape[0], 1)), W=X[:, 1:])
9.73638006...e-05
>>> est.rlearner_model_final_.model
LinearRegression(fit_intercept=False)
>>> est.rlearner_model_final_.model.coef_
array([0.999631...])
>>> est.score_
9.82623204...e-05
>>> [mdl._model for mdls in est.models_y for mdl in mdls]
[LinearRegression(), LinearRegression()]
>>> [mdl._model for mdls in est.models_t for mdl in mdls]
[LinearRegression(), LinearRegression()]
models_y

model_y 对象的实例的嵌套列表。子列表的数量等于蒙特卡洛迭代次数，子列表中的每个元素对应一个交叉拟合折，并且是为该训练折拟合的模型实例。

类型

类型为 type(model_y) 的对象的嵌套列表

models_t

model_t 对象的实例的嵌套列表。子列表的数量等于蒙特卡洛迭代次数，子列表中的每个元素对应一个交叉拟合折，并且是为该训练折拟合的模型实例。

类型

类型为 type(model_t) 的对象的嵌套列表

rlearner_model_final_

调用 fit 后拟合的 model_final 对象的实例。

类型

类型为 type(model_final) 的对象

score_

最终残差对残差回归的 MSE

类型

浮点数

nuisance_scores_y

每个结果模型的样本外得分

类型

浮点数的嵌套列表

nuisance_scores_t

每个处理模型的样本外得分

\[\frac{1}{n} \sum_{i=1}^n (Y_i - \hat{E}[Y|X_i, W_i] - \hat{\theta}(X_i)\cdot (T_i - \hat{E}[T|X_i, W_i]))^2\]

如果在 fit 时 sample_weight 不为 None，则返回加权平均值。如果结果 Y 是多维的，则返回 Y 的每个维度的 MSE 的平均值。

类型

浮点数的嵌套列表

ate(X=None, *, T0=0, T1=1)

计算平均处理效应 \(E_X[\tau(X, T0, T1)]\)。

效应在两个处理点之间计算，并在 X 变量总体上求平均。

参数

  • T0 ((m, d_t) 矩阵或长度为 m 的向量) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量) – 每个样本的目标处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

τ – 对每个结果的平均处理效应。请注意，当 Y 是向量而不是二维数组时，结果将是标量。

返回类型

float 或 (d_y,) 数组

ate_inference(X=None, *, T0=0, T1=1)

模型产生的量 \(E_X[\tau(X, T0, T1)]\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • T0 ((m, d_t) 矩阵或长度为 m 的向量, 默认 0) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量, 默认 1) – 每个样本的目标处理变量

返回

PopulationSummaryResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

ate_interval(X=None, *, T0=0, T1=1, alpha=0.05)

模型产生的量 \(E_X[\tau(X, T0, T1)]\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • T0 ((m, d_t) 矩阵或长度为 m 的向量, 默认 0) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量, 默认 1) – 每个样本的目标处理变量

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of ate(X, T0, T1), type of ate(X, T0, T1)) )

cate_feature_names(feature_names=None)

获取特征名称的公共接口。

由对输入特征应用转换的估计器覆盖此方法。

参数

feature_names (长度为 X.shape[1] 的 str 列表或 None) – 输入特征的名称。如果为 None 且 X 是 DataFrame，则默认使用 DataFrame 的列名。

返回

out_feature_names – 返回特征名称。

返回类型

str 列表或 None

cate_output_names(output_names=None)

获取输出名称的公共接口。

由对输出应用转换的估计器覆盖此方法。

参数

output_names (长度为 Y.shape[1] 的 str 列表或 None) – 结果的名称。如果为 None 且传递给 fit 的 Y 是 DataFrame，则默认使用 DataFrame 的列名。

返回

output_names – 返回输出名称。

返回类型

str 列表

cate_treatment_names(treatment_names=None)

获取处理变量名称。

如果处理变量是离散的或经过特征化的，它将返回扩展的处理变量名称。

参数

treatment_names (长度为 T.shape[1] 的 str 列表, 可选) – 处理变量的名称。如果为 None 且传递给 fit 的 T 是 DataFrame，则默认使用 DataFrame 的列名。

返回

out_treatment_names – 返回（可能已扩展的）处理变量名称。

返回类型

str 列表

const_marginal_ate(X=None)

计算平均常数边际 CATE \(E_X[\theta(X)]\)。

参数

X ((m, d_x) 矩阵, 可选) – 每个样本的特征。

返回

theta – 每个处理变量对每个结果的平均常数边际 CATE。请注意，当 Y 或 featurized-T（如果 treatment_featurizer 为 None，则为 T）是向量而不是二维数组时，输出中相应的单维将被折叠（例如，如果两者都是向量，则此方法的输出也将是标量）

返回类型

(d_y, d_f_t) 矩阵，其中 d_f_t 是特征化处理变量的维度。如果 treatment_featurizer 为 None，则 d_f_t = d_t。

const_marginal_ate_inference(X=None)

模型产生的量 \(E_X[\theta(X)]\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

PopulationSummaryResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

const_marginal_ate_interval(X=None, *, alpha=0.05)

模型产生的量 \(E_X[\theta(X)]\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of const_marginal_ate(X) , type of const_marginal_ate(X) )

const_marginal_effect(X=None)

计算常数边际 CATE \(\theta(·)\)。

边际效应是条件于 m 个测试样本 X[i] 的特征向量的。

参数

X ((m, d_x) 矩阵, 可选) – 每个样本的特征。

返回

theta – 每个特征化处理变量对每个结果在每个样本 X[i] 上的常数边际 CATE。请注意，当 Y 或 featurized-T（如果 treatment_featurizer 为 None，则为 T）是向量而不是二维数组时，输出中相应的单维将被折叠（例如，如果两者都是向量，则此方法的输出也将是向量）

返回类型

(m, d_y, d_f_t) 矩阵或 (d_y, d_f_t) 矩阵（如果 X 为 None），其中 d_f_t 是特征化处理变量的维度。如果 treatment_featurizer 为 None，则 d_f_t = d_t。

const_marginal_effect_inference(X=None)

模型产生的量 \(\theta(X)\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

InferenceResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

const_marginal_effect_interval(X=None, *, alpha=0.05)

模型产生的量 \(\theta(X)\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of const_marginal_effect(X) , type of const_marginal_effect(X) )

effect(X=None, *, T0=0, T1=1)

计算异质处理效应 \(\tau(X, T0, T1)\)。

效应在两个处理点之间计算，并条件于 m 个测试样本 \(\{T0_i, T1_i, X_i\}\) 的特征向量。

参数

  • T0 ((m, d_t) 矩阵或长度为 m 的向量) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量) – 每个样本的目标处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

τ – 每个处理变量对每个结果在每个样本上的异质处理效应。请注意，当 Y 是向量而不是二维数组时，相应的单维将被折叠（因此此方法将返回一个向量）

返回类型

(m, d_y) 矩阵

effect_inference(X=None, *, T0=0, T1=1)

模型产生的量 \(\tau(X, T0, T1)\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • T0 ((m, d_t) 矩阵或长度为 m 的向量, 默认 0) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量, 默认 1) – 每个样本的目标处理变量

返回

InferenceResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

effect_interval(X=None, *, T0=0, T1=1, alpha=0.05)

模型产生的量 \(\tau(X, T0, T1)\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • T0 ((m, d_t) 矩阵或长度为 m 的向量, 默认 0) – 每个样本的基础处理变量

  • T1 ((m, d_t) 矩阵或长度为 m 的向量, 默认 1) – 每个样本的目标处理变量

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of effect(X, T0, T1), type of effect(X, T0, T1)) )

fit(Y, T, *, X=None, W=None, sample_weight=None, freq_weight=None, sample_var=None, groups=None, cache_values=False, inference=None)[source]

从数据中估计反事实模型，即估计函数 \(\theta(\cdot)\)。

参数

  • Y ((n, d_y) 矩阵或长度为 n 的向量) – 每个样本的结果

  • T ((n, d_t) 矩阵或长度为 n 的向量) – 每个样本的处理变量

  • X ((n, d_x) 矩阵, 可选) – 每个样本的特征

  • W ((n, d_w) 矩阵, 可选) – 每个样本的控制变量

  • sample_weight ((n,) array_like, 可选) – 每个样本的个体权重。如果为 None，则假设权重相等。

  • freq_weight ((n, ) array_like of int, 可选) – 观测的权重。观测 i 被视为 freq_weight[i] 个独立观测的平均结果。当 sample_var 不为 None 时，应提供此参数。

  • sample_var ({(n,), (n, d_y)} nd array_like, 可选) – 用于计算观测 i 所代表的平均结果的原始 freq_weight[i] 个观测的结果方差。

  • groups ((n,) 向量, 可选) – 同一组的所有行在分割时将被保持在一起。如果 groups 不为 None，则传递给此类的初始化器的 cv 参数必须支持其 split 方法的 ‘groups’ 参数。

  • cache_values (bool, 默认 False) – 是否缓存输入和第一阶段结果，这将允许重新拟合不同的最终模型

  • inference (str, Inference 实例, 或 None) – 执行推断的方法。此估计器支持 ‘bootstrap’（或 :class:.BootstrapInference 的一个实例）。

返回

自身

返回类型

_RLearner 实例

marginal_ate(T, X=None)

计算平均边际效应 \(E_{T, X}[\partial\tau(T, X)]\)。

边际效应在基础处理点周围计算，并在 X 的总体上求平均。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

grad_tau – 对每个结果的平均边际效应。请注意，当 Y 或 T 是向量而不是二维数组时，输出中相应的单维将被折叠（例如，如果两者都是向量，则此方法的输出将是标量）

返回类型

(d_y, d_t) 数组

marginal_ate_inference(T, X=None)

模型产生的量 \(E_{T,X}[\partial \tau(T, X)]\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

PopulationSummaryResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

marginal_ate_interval(T, X=None, *, alpha=0.05)

模型产生的量 \(E_{T,X}[\partial \tau(T, X)]\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of marginal_ate(T, X), type of marginal_ate(T, X) )

marginal_effect(T, X=None)

计算异质边际效应 \(\partial\tau(T, X)\)。

边际效应在基础处理点周围计算，并条件于 m 个测试样本 \(\{T_i, X_i\}\) 的特征向量。如果 treatment_featurizer 为 None，则在此计算中忽略基础处理，结果等同于 const_marginal_effect。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

grad_tau – 每个处理变量对每个结果在每个样本上的异质边际效应。请注意，当 Y 或 T 是向量而不是二维数组时，输出中相应的单维将被折叠（例如，如果两者都是向量，则此方法的输出也将是向量）

返回类型

(m, d_y, d_t) 数组

marginal_effect_inference(T, X=None)

模型产生的量 \(\partial \tau(T, X)\) 的推断结果。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

返回

InferenceResults – 推断结果实例包含预测值和预测标准误差，并可以根据需要计算置信区间、z 统计量和 p 值。它还可以输出这些推断结果的 DataFrame 汇总。

返回类型

对象

marginal_effect_interval(T, X=None, *, alpha=0.05)

模型产生的量 \(\partial \tau(T, X)\) 的置信区间。仅当调用 fit 方法时 inference 不为 None 时可用。

参数

  • T ((m, d_t) 矩阵) – 每个样本的基础处理变量

  • X ((m, d_x) 矩阵, 可选) – 每个样本的特征

  • alpha (float, 范围 [0, 1], 默认 0.05) – 报告区间的总置信水平。报告的是 alpha/2, 1-alpha/2 置信区间。

返回

lower, upper – 每个量的置信区间的下界和上界。

返回类型

tuple(type of marginal_effect(T, X), type of marginal_effect(T, X) )

refit_final(inference=None)

使用新的最终模型规范，但使用缓存的第一阶段结果来估计反事实模型。

为了使其成功，必须在调用 fit 时设置 cache_values=True。此调用只会重新拟合最终模型。此调用将使用更改最终阶段估计的任何参数的当前设置。如果更改了任何参数以更改第一阶段“讨厌”估计的方式，则此调用将无效。您需要再次调用 fit 以更改第一阶段估计结果。

参数

inference (推断方法, 可选) – 表示推断方法的字符串或对象

返回

self – 此实例

返回类型

对象

score(Y, T, X=None, W=None, sample_weight=None)[source]

在新数据集上对已拟合的 CATE 模型评分。基于在 fit 时创建的已拟合的残差“讨厌”模型，为新数据集生成“讨厌”参数。它使用不同交叉拟合折拟合的模型的平均预测值。然后计算最终残差 Y 对残差 T 回归的 MSE。

如果 model_final 没有 score 方法，则会引发 AttributeError

参数

  • Y ((n, d_y) 矩阵或长度为 n 的向量) – 每个样本的结果

  • T ((n, d_t) 矩阵或长度为 n 的向量) – 每个样本的处理变量

  • X ((n, d_x) 矩阵, 可选) – 每个样本的特征

  • W ((n, d_w) 矩阵, 可选) – 每个样本的控制变量

  • sample_weight ((n,) 向量, 可选) – 每个样本的权重

返回

score – 最终 CATE 模型在新数据上的 MSE。

返回类型

浮点数

shap_values(X, *, feature_names=None, treatment_names=None, output_names=None, background_samples=100)

最终阶段模型 (const_marginal_effect) 的 Shap 值

参数

  • X ((m, d_x) 矩阵) – 每个样本的特征。应与最终阶段拟合的 X 形状相同。

  • feature_names (长度为 X.shape[1] 的 str 列表, 可选) – 输入特征的名称。

  • treatment_names (list, 可选) – 特征化处理变量的名称。在离散处理变量场景中，名称不应包含基线处理变量的名称（即对照处理变量，默认是按字母顺序较小的那个）

  • output_names (list, 可选) – 结果的名称。

  • background_samples (int , 默认 100) – 用于计算基线效应的样本数量。如果为 None，则使用所有样本。

返回

shap_outs – 一个嵌套字典，使用每个输出名称（例如，当 output_names=None 时为 ‘Y0’, ‘Y1’, …）和每个处理变量名称（例如，当 treatment_names=None 时为 ‘T0’, ‘T1’, …）作为键，并以 shap_values 解释对象作为值。如果在 fit 时输入的 데이터 也包含元数据（例如，是 pandas DataFrame），则使用处理变量、结果和特征的列元数据，而不是上述默认值（除非用户通过显式传递相应的名称进行覆盖）。

返回类型

Explanation 对象的嵌套字典

property dowhy

获取 DoWhyWrapper 的实例，以使用 dowhy 包的其他功能。（例如，因果图、反驳测试等）

返回

DoWhyWrapper – DoWhyWrapper 的一个实例

返回类型

实例

property residuals_

一个元组 (y_res, T_res, X, W)，包含第一阶段估计的残差以及相关的 X 和 W。样本的顺序不保证与输入顺序相同。