dowhy.causal_refuters 包#

子模块#

dowhy.causal_refuters.add_unobserved_common_cause 模块#

class dowhy.causal_refuters.add_unobserved_common_cause.AddUnobservedCommonCause(*args, **kwargs)[source]#

基类: CausalRefuter

添加一个未观测到的混杂因素进行反驳。

AddUnobservedCommonCause 类支持三种方法

模拟一个未观测到的混杂因素
线性偏 R2：线性模型的敏感性分析。
基于非参数偏 R2：非参数模型的敏感性分析。

支持可在 refute_estimate() 方法中指定的附加参数。

初始化反驳器所需的参数。

对于 direct_simulation，如果未给出 effect_strength_on_treatment 或 effect_strength_on_outcome，则会自动计算，其范围介于观测到的混杂因素对治疗和结果的最小和最大效应强度之间。

参数:

simulation_method – 用于模拟未观测到的混杂因素效应的方法。可能的值包括 [“direct-simulation”, “linear-partial-R2”, “non-parametric-partial-R2”, “e-value”]。
confounders_effect_on_treatment – str : 未观测到的混杂因素对治疗产生的效应类型。可能的值包括 ['binary_flip', 'linear']
confounders_effect_on_outcome – str : 未观测到的混杂因素对结果产生的效应类型。可能的值包括 ['binary_flip', 'linear']
effect_strength_on_treatment – float, numpy.ndarray: [当 simulation_method=”direct-simulation” 时使用] 混杂因素对治疗的效应强度。当 confounders_effect_on_treatment 是线性时，它是回归系数。当 confounders_effect_on_treatment 是二元翻转时，它是未观测到的混杂因素效应可以反转治疗值的概率。
effect_strength_on_outcome – float, numpy.ndarray: 混杂因素对结果的效应强度。其解释取决于 confounders_effect_on_outcome 和 simulation_method。当 simulation_method 是 direct-simulation 时，对于线性效应，其行为类似于回归系数；对于二元翻转，它是它可以反转结果值的概率。
partial_r2_confounder_treatment – float, numpy.ndarray: [当 simulation_method 是 linear-partial-R2 或 non-parametric-partial-R2 时使用] 未观测到的混杂因素相对于以观测到的混杂因素为条件的治疗的偏 R2。仅在一般 non-parametric-partial-R2 的情况下，它是未观测到的混杂因素解释的 reisz representer 的方差比例；具体来说是 (1-r)，其中 r 是基于观测到的混杂因素和基于所有混杂因素的 reisz representer (alpha^2) 方差之比。
partial_r2_confounder_outcome – float, numpy.ndarray: [当 simulation_method 是 linear-partial-R2 或 non-parametric-partial-R2 时使用] 未观测到的混杂因素相对于以治疗和观测到的混杂因素为条件的结果的偏 R2。
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
plotmethod – string: 要显示的图表类型。如果为 None，则不生成图表。仅当提供了多个治疗混杂因素效应值或结果混杂因素效应值时才使用此参数。默认值为“colormesh”。当两个混杂因素效应值参数都提供了多个值时，支持的值为“contour”，“colormesh”；仅提供其中一个时，支持的值为“line”。
percent_change_estimate – 这是可能改变结果的治疗估计值减少百分比（默认值 = 1）。如果 percent_change_estimate = 1，则稳健性值描述了混杂因素与治疗和结果关联的强度，以便将估计值降低 100%，即降至 0。（仅与线性敏感性分析相关，其余情况忽略）
confounder_increases_estimate – True 表示混杂因素增加了估计值的绝对值，反之亦然。（默认值 = False）。（仅与线性敏感性分析相关，其余情况忽略）
benchmark_common_causes – 用于限定混杂因素强度的变量名称。（仅与基于偏 R2 的模拟方法相关）
significance_level – 统计推断的置信区间（默认值 = 0.05）。（仅与基于偏 R2 的模拟方法相关）
null_hypothesis_effect – 零假设下的假定效应。（仅与 linear-partial-R2 相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计值的等高线图。（默认值 = True）。（仅与基于偏 R2 的模拟方法相关）
num_splits – 交叉验证的分裂次数。（默认值 = 5）。（仅与 non-parametric-partial-R2 模拟方法相关）

:param shuffle_data : 在将数据分割成折叠之前是否打乱数据（默认值 = False）。（仅与 non-parametric-partial-R2 模拟方法相关） :param shuffle_random_seed: 用于随机打乱数据的种子。（仅与 non-parametric-partial-R2 模拟方法相关） :param alpha_s_estimator_param_list: 包含用于查找 alpha_s 的参数的字典列表。（仅与 non-parametric-partial-R2 模拟方法相关） :param g_s_estimator_list: 用于查找 g_s 的估计器对象列表。这些对象应具有 fit() 和 predict() 函数。（仅与 non-parametric-partial-R2 模拟方法相关） :param g_s_estimator_param_list: 包含用于调整 “g_s_estimator_list” 中相应估计器的参数的字典列表。列表中字典的顺序应与 “g_s_estimator_list” 中估计器对象的顺序一致。（仅与 non-parametric-partial-R2 模拟方法相关）

include_simulated_confounder(convergence_threshold=0.1, c_star_max=1000)[source]#

refute_estimate(show_progress_bar=False)[source]#

dowhy.causal_refuters.add_unobserved_common_cause.include_simulated_confounder(data: DataFrame, treatment_name: str, outcome_name: str, kappa_t: float, kappa_y: float, variables_of_interest: List, convergence_threshold: float = 0.1, c_star_max: int = 1000)[source]#

此函数根据数据使用以下步骤模拟未观测到的混杂因素：1. 它计算治疗和结果模型的“残差”：i.) 结果模型以结果为因变量，以所有观测到的变量（包括治疗）为自变量 ii.) 治疗模型以治疗为因变量，以所有观测到的变量为自变量。

2. U 是一个中间随机变量，从正态分布中抽取，其均值为残差的加权平均值，方差为单位方差 U ~ N(c1*d_y + c2*d_t, 1)，其中 d_y 和 d_t 是治疗和结果模型的残差，c1 和 c2 是残差的系数。

最终的 U（即模拟的未观测到的混杂因素）是通过对中间变量 U 进行去偏而获得的，方法是使用 X 对其进行残差化处理。

选择系数 c1 和 c2：系数的选择基于这些基本假设：1. 存在满足 c1*c2 = c_star 的双曲线关系。2. 根据获得的模拟变量与结果和治疗的相关性，从可能的值范围中选择 c_star。3. 与治疗和结果的相关性乘积应与任何观测到的混杂因素中与治疗和结果的最大相关性保持最小距离。4. 权重的比率应使其在某个置信区间内保持最大可能观测系数的比率。

参数:

c_star_max – 残差系数所在双曲线的最大可能值。如果用户未指定，代码中默认为 1000。 :type int
convergence_threshold – 在选择 c_star 时检查相关性是否趋于稳定的阈值。如果用户未指定，代码中默认为 0.1 :type float

返回值:

基于数据模拟的未观测到的混杂因素值 :type pandas.core.series.Series

dowhy.causal_refuters.add_unobserved_common_cause.preprocess_observed_common_causes(data: DataFrame, target_estimand: IdentifiedEstimand, no_common_causes_error_message: str)[source]#

预处理后门变量（观测到的共同原因）并返回预处理后的矩阵。

至少需要一个后门（共同原因）变量。如果不存在，则引发异常。

预处理包括两个步骤：1. 类别编码。2. 标准化。

参数:

data – 所有数据，其中一部分需要预处理。
target_estimand – 包括后门变量定义的期望效应的估计目标。
no_common_causes_error_message – 如果不存在后门变量，则在 ValueError 中显示的消息。

返回值:

包含预处理数据的 DataFrame。

dowhy.causal_refuters.add_unobserved_common_cause.sensitivity_e_value(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_name: List[str], outcome_name: List[str], plot_estimate: bool = True) → EValueSensitivityAnalyzer[source]#

dowhy.causal_refuters.add_unobserved_common_cause.sensitivity_linear_partial_r2(data: DataFrame, estimate: CausalEstimate, treatment_name: str, frac_strength_treatment: float = 1.0, frac_strength_outcome: float = 1.0, percent_change_estimate: float = 1.0, benchmark_common_causes: List[str] | None = None, significance_level: float | None = None, null_hypothesis_effect: float | None = None, plot_estimate: bool = True) → LinearSensitivityAnalyzer[source]#

使用线性偏 R2 方法（线性模型的敏感性分析）添加一个未观测到的混杂因素进行反驳。

参数:

data – pd.DataFrame: 用于运行反驳的数据
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 治疗名称
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
percent_change_estimate – 这是可能改变结果的治疗估计值减少百分比（默认值 = 1）。如果 percent_change_estimate = 1，则稳健性值描述了混杂因素与治疗和结果关联的强度，以便将估计值降低 100%，即降至 0。（仅与线性敏感性分析相关，其余情况忽略）
benchmark_common_causes – 用于限定混杂因素强度的变量名称。（仅与基于偏 R2 的模拟方法相关）
significance_level – 统计推断的置信区间（默认值 = 0.05）。（仅与基于偏 R2 的模拟方法相关）
null_hypothesis_effect – 零假设下的假定效应。（仅与 linear-partial-R2 相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计值的等高线图。（默认值 = True）。（仅与基于偏 R2 的模拟方法相关）

dowhy.causal_refuters.add_unobserved_common_cause.sensitivity_non_parametric_partial_r2(estimate: CausalEstimate, kappa_t: float | ndarray | None = None, kappa_y: float | ndarray | None = None, frac_strength_treatment: float = 1.0, frac_strength_outcome: float = 1.0, benchmark_common_causes: List[str] | None = None, plot_estimate: bool = True, alpha_s_estimator_list: List | None = None, alpha_s_estimator_param_list: List[Dict] | None = None, g_s_estimator_list: List | None = None, g_s_estimator_param_list: List[Dict] | None = None, plugin_reisz: bool = False)[source]#

使用非参数偏 R2 方法（非参数模型的敏感性分析）添加一个未观测到的混杂因素进行反驳。

参数:

estimate – CausalEstimate: 用于运行反驳的估计值
kappa_t – float, numpy.ndarray: 未观测到的混杂因素相对于以观测到的混杂因素为条件的治疗的偏 R2。仅在一般 non-parametric-partial-R2 的情况下，它是未观测到的混杂因素解释的 reisz representer 的方差比例；具体来说是 (1-r)，其中 r 是基于观测到的混杂因素和基于所有混杂因素的 reisz representer (alpha^2) 方差之比。
kappa_y – float, numpy.ndarray: 未观测到的混杂因素相对于以治疗和观测到的混杂因素为条件的结果的偏 R2。
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
benchmark_common_causes – 用于限定混杂因素强度的变量名称。（仅与基于偏 R2 的模拟方法相关）
plot_estimate – 在执行敏感性分析时生成估计值的等高线图。（默认值 = True）。（仅与基于偏 R2 的模拟方法相关）
alpha_s_estimator_list – 用于估计 alpha_s 的估计器对象列表。这些对象应具有 fit() 和 predict() 方法（仅与 non-parametric-partial-R2 方法相关）
alpha_s_estimator_param_list – 包含用于查找 alpha_s 的参数的字典列表。（仅与 non-parametric-partial-R2 模拟方法相关）
g_s_estimator_list – 用于查找 g_s 的估计器对象列表。这些对象应具有 fit() 和 predict() 函数。（仅与 non-parametric-partial-R2 模拟方法相关）
g_s_estimator_param_list – 包含用于调整 “g_s_estimator_list” 中相应估计器的参数的字典列表。列表中字典的顺序应与 “g_s_estimator_list” 中估计器对象的顺序一致。（仅与 non-parametric-partial-R2 模拟方法相关）

Plugin_reisz:

bool: 指示是使用插件估计器还是非参数估计器来估计 reisz representer 函数 (alpha_s) 的标志。

dowhy.causal_refuters.add_unobserved_common_cause.sensitivity_simulation(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_name: str, outcome_name: str, kappa_t: float | ndarray | None = None, kappa_y: float | ndarray | None = None, confounders_effect_on_treatment: str = 'binary_flip', confounders_effect_on_outcome: str = 'linear', frac_strength_treatment: float = 1.0, frac_strength_outcome: float = 1.0, plotmethod: str | None = None, show_progress_bar=False, **_) → CausalRefutation[source]#

此函数尝试向结果和治疗中添加一个未观测到的共同原因。目前，我们已实现了连续变量和二元变量的一维行为。此函数可以接受单值输入或输入范围。然后，函数会查看输入的数据类型，并决定采取的行动。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 治疗名称
outcome_name – str: 结果名称
kappa_t – float, numpy.ndarray: 混杂因素对治疗的效应强度。当 confounders_effect_on_treatment 是线性时，它是回归系数。当 confounders_effect_on_treatment 是二元翻转时，它是未观测到的混杂因素效应可以反转治疗值的概率。
kappa_y – float, numpy.ndarray: 混杂因素对结果的效应强度。其解释取决于 confounders_effect_on_outcome 和 simulation_method。当 simulation_method 是 direct-simulation 时，对于线性效应，其行为类似于回归系数；对于二元翻转，它是它可以反转结果值的概率。
confounders_effect_on_treatment – str : 未观测到的混杂因素对治疗产生的效应类型。可能的值包括 ['binary_flip', 'linear']
confounders_effect_on_outcome – str : 未观测到的混杂因素对结果产生的效应类型。可能的值包括 ['binary_flip', 'linear']
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
plotmethod – string: 要显示的图表类型。如果为 None，则不生成图表。仅当提供了多个治疗混杂因素效应值或结果混杂因素效应值时才使用此参数。默认值为“colormesh”。当两个混杂因素效应值参数都提供了多个值时，支持的值为“contour”，“colormesh”；仅提供其中一个时，支持的值为“line”。

返回值:

CausalRefuter: 包含估计效应、新效应以及使用的反驳方法名称的对象。

dowhy.causal_refuters.assess_overlap 模块#

class dowhy.causal_refuters.assess_overlap.AssessOverlap(*args, **kwargs)[source]#

基类: CausalRefuter

评估重叠

此类实现了 OverRule 算法，用于通过布尔规则集评估支持和重叠，引自 [1]。

[1] Oberst, M., Johansson, F., Wei, D., Gao, T., Brat, G., Sontag, D., & Varshney, K. (2020). Characterization of Overlap in Observational Studies. In S. Chiappa & R. Calandra (编), 人工智能与统计学第二十三届国际会议论文集 (第 108 卷, 页 788–798). PMLR. https://arxiv.org/abs/1907.04138

初始化反驳器所需的参数。

参数会传递给 refute_estimate 方法。有关定义优化超参数的 SupportConfig 和 OverlapConfig 数据类的定义，请参阅 dowhy.causal_refuters.assess_overlap_overrule。

警告

此方法仅与使用后门调整的估计器兼容，并将尝试通过 self._target_estimand.get_backdoor_variables() 获取后门变量集。

参数:: cat_feats: List[str]: 类别特征列表，所有其他特征将进行离散化
参数:: support_config: SupportConfig: DataClass，包含学习支持规则的配置选项
参数:: overlap_config: OverlapConfig: DataClass，包含学习重叠规则的配置选项
参数:: overlap_eps: float: 定义将某个点视为重叠区域内的倾向性得分范围，该范围定义为 (overlap_eps, 1 - overlap_eps)，默认为 0.1
参数:: overrule_verbose: bool: 启用优化输出的详细日志记录，默认为 False
参数:: support_only: bool: 仅拟合描述支持区域的规则（不拟合重叠规则），默认为 False
参数:: overlap_only: bool: 仅拟合描述重叠区域的规则（不拟合支持规则），默认为 False

refute_estimate(show_progress_bar=False)[source]#

学习重叠和支持规则。

参数:: show_progress_bar (bool) – 未实现，如果设置为 True 将引发错误，默认为 False
引发:: NotImplementedError – 如果 show_progress_bar=True，将引发此错误
返回值:: OverruleAnalyzer 类的对象

dowhy.causal_refuters.assess_overlap.assess_support_and_overlap_overrule(data, backdoor_vars: List[str], treatment_name: str, cat_feats: List[str] = [], overlap_config: OverlapConfig | None = None, support_config: SupportConfig | None = None, overlap_eps: float = 0.1, support_only: bool = False, overlap_only: bool = False, verbose: bool = False)[source]#

使用 OverRule 学习支持和重叠规则。

参数:

data – 包含后门变量和治疗名称的数据
backdoor_vars – 后门变量列表。支持和重叠规则将仅相对于

这些变量 :type backdoor_vars: List[str] :param treatment_name: 治疗名称 :type treatment_name: str :param cat_feats: 类别特征 :type cat_feats: List[str] :param overlap_config: 学习重叠规则的配置 :type overlap_config: OverlapConfig :param support_config: 学习支持规则的配置 :type support_config: SupportConfig :param: overlap_eps: float: 定义将某个点视为重叠

区域内的倾向性得分范围，该范围定义为 (overlap_eps, 1 - overlap_eps)，默认为 0.1

参数:: support_only: bool: 仅拟合支持区域
参数:: overlap_only: bool: 仅拟合重叠区域
参数:: verbose: bool: 启用优化输出的详细日志记录，默认为 False

dowhy.causal_refuters.assess_overlap_overrule 模块#

class dowhy.causal_refuters.assess_overlap_overrule.OverlapConfig(alpha: float = 0.95, lambda0: float = 0.001, lambda1: float = 0.001, K: int = 20, D: int = 20, B: int = 10, iterMax: int = 10, num_thresh: int = 9, thresh_override: Dict | None = None, solver: str = 'ECOS', rounding: str = 'greedy_sweep')[source]#

基类: object

学习重叠规则的配置。

参数:

alpha (float, 可选) – 确保包含在规则中的重叠样本比例，默认为 0.95
lambda0 (float, 可选) – 规则数量的正则化，默认为 1e-3
lambda1 (float, 可选) – 字面量数量的正则化，默认为 1e-3
K (int, 可选) – 集束搜索期间返回的最大结果数，默认为 20
D (int, 可选) – 每次集束搜索迭代的最大额外规则数，默认为 20
B (int, 可选) – 集束搜索宽度，默认为 10
iterMax (int, 可选) – 列生成的最大迭代次数，默认为 10
num_thresh (int, 可选) – 离散化连续变量的 bin 数，默认为 9（表示十分位数）
thresh_override (Optional[Dict], 可选) – 手动覆盖连续特征的阈值，以字典形式给出，如下所示，仅应用于具有多于 num_thresh 个唯一值的连续特征 thresh_override = {column_name: np.linspace(0, 100, 10)}
solver (str, 可选) – CVXPY 用于解决 LP 松弛问题的线性规划求解器，默认为 'ECOS'
rounding (str, 可选) – 执行舍入的策略，可以是 'greedy' 或 'greedy_sweep'，默认为 'greedy_sweep'

B: int = 10#

D: int = 20#

K: int = 20#

alpha: float = 0.95#

iterMax: int = 10#

lambda0: float = 0.001#

lambda1: float = 0.001#

num_thresh: int = 9#

rounding: str = 'greedy_sweep'#

solver: str = 'ECOS'#

thresh_override: Dict | None = None#

class dowhy.causal_refuters.assess_overlap_overrule.OverruleAnalyzer(backdoor_vars: List[str], treatment_name: str, cat_feats: List[str] | None = None, support_config: SupportConfig | None = None, overlap_config: OverlapConfig | None = None, prop_estimator: BaseEstimator | GridSearchCV | None = None, overlap_eps: float = 0.1, support_only: bool = False, overlap_only: bool = False, verbose: bool = False)[source]#

基类: object

学习支持和重叠规则。

参数:: backdoor_vars – 后门变量列表。支持和重叠规则将仅相对于

这些变量 :type backdoor_vars: List[str] :param treatment_name: 治疗名称 :type treatment_name: str :param: cat_feats: List[str]: 类别特征列表，所有其他特征将进行离散化 :param: support_config: SupportConfig: DataClass，包含学习支持规则的配置选项 :param: overlap_config: OverlapConfig: DataClass，包含学习重叠规则的配置选项 :param: overrule_verbose: bool: 启用优化输出的详细日志记录，默认为 False :param prop_estimator: 倾向性得分估计器，默认为通过 GridSearchCV 学习的 RandomForestClassifier :type prop_estimator: Optional[Union[BaseEstimator, GridSearchCV]], optional :param: overlap_eps: float: 定义将某个点视为重叠

区域内的倾向性得分范围，该范围定义为 (overlap_eps, 1 - overlap_eps)，默认为 0.1

参数:

support_only (bool, 可选) – 仅拟合支持区域，不拟合重叠区域，默认为 False
overlap_only (bool, 可选) – 仅拟合重叠区域，不拟合支持区域，默认为 False
verbose (bool, 可选) – 详细的优化输出，默认为 False

describe_all_rules()[source]#

describe_overlap_rules()[source]#

describe_support_rules()[source]#

filter_dataframe(data: DataFrame)[source]#

fit(data: DataFrame) → None[source]#

predict_overlap_support(data: DataFrame)[source]#

class dowhy.causal_refuters.assess_overlap_overrule.SupportConfig(n_ref_multiplier: float = 1.0, seed: int | None = None, alpha: float = 0.98, lambda0: float =0.01, lambda1: float =0.001, K: int =20, D: int =20, B: int =10, iterMax: int =10, num_thresh: int =9, thresh_override: Dict | None =None, solver: str ='ECOS', rounding: str ='greedy_sweep')[source]#

基类: object

学习支持规则的配置。

参数:

n_ref_multiplier (float, 可选) – 参考样本计数乘数，默认为 1.0
seed (int, 可选) – 参考样本的随机种子，仅用于估计支持，默认为 None
alpha (float, 可选) – 确保包含在规则中的现有示例比例，默认为 0.98
lambda0 (float, 可选) – 规则数量的正则化，默认为 1e-2
lambda1 (float, 可选) – 字面量数量的正则化，默认为 1e-3
K (int, 可选) – 集束搜索期间返回的最大结果数，默认为 20
D (int, 可选) – 每次集束搜索迭代的最大额外规则数，默认为 20
B (int, 可选) – 集束搜索宽度，默认为 10
iterMax (int, 可选) – 列生成的最大迭代次数，默认为 10
num_thresh (int, 可选) – 离散化连续变量的 bin 数，默认为 9（表示十分位数）
thresh_override (Optional[Dict], 可选) – 手动覆盖连续特征的阈值，以字典形式给出，如下所示，仅应用于具有多于 num_thresh 个唯一值的连续特征 thresh_override = {column_name: np.linspace(0, 100, 10)}
solver (str, 可选) – CVXPY 用于解决 LP 松弛问题的线性规划求解器，默认为 'ECOS'
rounding (str, 可选) – 执行舍入的策略，可以是 'greedy' 或 'greedy_sweep'，默认为 'greedy_sweep'

B: int = 10#

D: int = 20#

K: int = 20#

alpha: float = 0.98#

iterMax: int = 10#

lambda0: float = 0.01#

lambda1: float = 0.001#

n_ref_multiplier: float = 1.0#

num_thresh: int =9#

rounding: str = 'greedy_sweep'#

seed: int | None = None#

solver: str = 'ECOS'#

thresh_override: Dict | None = None#

dowhy.causal_refuters.bootstrap_refuter 模块#

class dowhy.causal_refuters.bootstrap_refuter.BootstrapRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过在包含混杂因子测量误差的数据随机样本上运行估计来驳斥估计。这允许我们找到估计器找出治疗对结果影响的能力。

它支持可以在 refute_estimate() 方法中指定的附加参数。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
sample_size (*int*, *可选*) – 每个自举样本的大小，默认为原始数据的大小
required_variables (*int*, *list*, *bool*, *可选*) – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

整数参数指定用于估计结果值的变量数量
列表参数显式指定用于估计结果的变量。此外，它还提供了显式选择或取消选择结果估计中存在的协变量的能力。这可以通过如下所示的从列表中添加或显式删除变量来实现

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。
如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

参数:

noise (*float*, *可选*) – 添加到数据的噪声的标准差，默认为 `BootstrapRefuter.DEFAULT_STD_DEV`
probability_of_change (*float*, *可选*) – 指定更改布尔或分类变量数据的概率。默认为 `noise`，仅当 `noise` 的值小于 1 时。
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。

DEFAULT_NUMBER_OF_TRIALS = 1#

DEFAULT_STD_DEV = 0.1#

DEFAULT_SUCCESS_PROBABILITY = 0.5#

refute_estimate(show_progress_bar: bool = False, *args, **kwargs)[source]#

dowhy.causal_refuters.bootstrap_refuter.refute_bootstrap(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, num_simulations: int = 100, random_state: int | RandomState | None = None, sample_size: int | None = None, required_variables: bool = True, noise: float = 0.1, probability_of_change: float | None = None, show_progress_bar: bool = False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过在包含混杂因子测量误差的数据随机样本上运行估计来驳斥估计。这允许我们找到估计器找出治疗对结果影响的能力。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
num_simulations – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。
sample_size – 每个自举样本的大小，默认为原始数据的大小
required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

整数参数指定用于估计结果值的变量数量
列表参数显式指定用于估计结果的变量。此外，它还提供了显式选择或取消选择结果估计中存在的协变量的能力。这可以通过如下所示的从列表中添加或显式删除变量来实现

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。
如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

3. 如果值为 True，则希望包含所有变量来估计结果值。.. warning:: `False` 值是 `INVALID` 的，将导致 `error`。:param noise: 添加到数据的噪声的标准差，默认为 `BootstrapRefuter.DEFAULT_STD_DEV` :param probability_of_change: 指定更改布尔或分类变量数据的概率

默认为 `noise`，仅当 `noise` 的值小于 1 时。

参数:

n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.data_subset_refuter 模块#

class dowhy.causal_refuters.data_subset_refuter.DataSubsetRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过在原始数据的随机子集上重新运行估计来驳斥估计。

支持可在 refute_estimate() 方法中指定的附加参数。有关 joblib 相关参数（n_jobs, verbose），请参阅 joblib 文档了解更多详细信息 (https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html)。

参数:

subset_fraction (*float*, *可选*) – 用于重新估计的数据比例，默认为 `DataSubsetRefuter.DEFAULT_SUBSET_FRACTION`。
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。如果希望重复相同的行为，我们在伪随机生成器中推入相同的种子
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

DEFAULT_SUBSET_FRACTION = 0.8#

refute_estimate(show_progress_bar: bool = False)[source]#

dowhy.causal_refuters.data_subset_refuter.refute_data_subset(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, subset_fraction: float = 0.8, num_simulations: int = 100, random_state: int | RandomState | None = None, show_progress_bar: bool = False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过在原始数据的随机子集上重新运行估计来驳斥估计。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
subset_fraction – 用于重新估计的数据比例，默认为 `DataSubsetRefuter.DEFAULT_SUBSET_FRACTION`。
num_simulations – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.dummy_outcome_refuter 模块#

dowhy.causal_refuters.dummy_outcome_refuter.DEFAULT_TRUE_CAUSAL_EFFECT(x)#

class dowhy.causal_refuters.dummy_outcome_refuter.DummyOutcomeRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过将结果替换为已知真实因果效应的模拟变量来驳斥估计。

在最简单的情况下，虚拟结果是一个独立的随机生成变量。根据定义，真实因果效应应为零。

更一般地，虚拟结果利用混杂因子与结果之间的观测关系（以治疗为条件）来创建更真实的结果，对于该结果，治疗效应已知为零。如果目标是模拟具有非零真实因果效应的虚拟结果，那么我们可以向虚拟结果的生成过程添加任意函数 h(t)，然后因果效应变为 h(t=1)-h(t=0)。

请注意，此通用过程仅适用于后门准则。

1. 我们为每个治疗值找到 f(W)。也就是说，保持治疗不变，我们拟合一个预测器来估计混杂因子 W 对结果 y 的影响。请注意，由于 f(W) 只是为模拟结果定义了一个新的 DGP，它不一定是 W 到 y 的正确结构方程。 2. 我们获得虚拟结果的值为：`y_dummy = h(t) + f(W)`

为了防止过拟合，我们对一个 T 值拟合 f(W)，然后用它来生成其他 t 值的数据。未来将支持基于工具变量和中介的识别。

If we originally started out with

       W
    /    \
    t --->y

On estimating the following with constant t,
y_dummy = f(W)

       W
    /     \
    t --|->y

This ensures that we try to capture as much of W--->Y as possible

On adding h(t)

       W
    /    \
    t --->y
      h(t)

支持可在 refute_estimate() 方法中指定的附加参数。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
transformation_list (*list*, *可选*) –
这是一个要执行以获得结果的操作列表，默认为 `DEFAULT_TRANSFORMATION`。默认变换如下

[("zero",""),("noise", {'std_dev':1} )]

变换中的每个操作都是以下类型之一

函数参数：函数 pd.Dataframe -> np.ndarray

它接受一个将输入数据框作为输入并输出结果变量的函数。这使我们能够创建一个仅依赖于协变量而不依赖于治疗变量的输出变量。

字符串参数

目前它支持一些常用的估计器，例如

线性回归

K近邻

支持向量机

神经网络

随机森林

或诸如以下函数

置换 (Permute) 这会置换结果的行，从而解除治疗对结果的任何影响。

噪声 (Noise) 这会向结果添加白噪声，减少与治疗的因果关系。

置零 (Zero) 它将结果中的所有值替换为零

示例
`transformation_list` 具有以下形式

如果函数 pd.Dataframe -> np.ndarray 已定义。 [(func,func_params),('permute',{'permute_fraction':val}),('noise',{'std_dev':val})]

每个函数应至少支持两个参数 X_train 和 outcome_train，它们分别对应于训练数据和我们要预测的结果，同时可以通过 func_args 设置学习率或动量常数等附加参数。

[(neural_network,{'alpha': 0.0001, 'beta': 0.9}),('permute',{'permute_fraction': 0.2}),('noise',{'std_dev': 0.1})]

神经网络按 neural_network(X_train, outcome_train, **args) 调用。

如果使用上述列表中的函数 [('knn',{'n_neighbors':5}), ('permute', {'permute_fraction': val} ), ('noise', {'std_dev': val} )]

参数:: true_causal_effect – 用于获取模拟虚拟结果的真实因果效应的函数。默认为 `DEFAULT_TRUE_CAUSAL_EFFECT`，这意味着在虚拟数据中，治疗和结果之间没有关系。

注

真实因果效应的输入形状应与治疗相同，输出形状应与结果匹配

参数:: required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。

如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

注

这些输入被馈送到估计结果变量的函数。对于内部估计函数的每个实例，都使用相同的 required_variables 集。

参数:

bucket_size_scale_factor – 对于连续数据，比例因子有助于我们调整数据上使用的桶的大小。默认比例因子为 `DEFAULT_BUCKET_SCALE_FACTOR`。
min_data_point_threshold (*int*, *可选*) – 估计器运行所需的最小数据点数量。默认为 `MIN_DATA_POINT_THRESHOLD`。如果某个类别的数据点数量过少，我们将使用 `DEFAULT_TRANSFORMATION` 来生成虚拟结果

refute_estimate(show_progress_bar: bool = False)[source]#

class dowhy.causal_refuters.dummy_outcome_refuter.TestFraction(base, other)#

基类: tuple

创建 TestFraction(base, other) 的新实例

base#: 字段号 0 的别名

other#: 字段号 1 的别名

dowhy.causal_refuters.dummy_outcome_refuter.noise(outcome: ndarray, std_dev: float)[source]#

添加均值为 0，标准差为 `std_dev` 的白噪声

参数:

**'outcome'** – *np.ndarray* 要添加白噪声的结果变量。
**'std_dev'** – *float* 白噪声的标准差。

返回值:

添加噪声后的结果

dowhy.causal_refuters.dummy_outcome_refuter.permute(outcome_name: str, outcome: ndarray, permute_fraction: float)[source]#

如果 `permute_fraction` 为 1，我们将置换结果中的所有值。否则，我们使用 Fisher Yates 洗牌算法。有关更多详细信息，请参阅 https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle。

参数:

**'outcome'** – *np.ndarray* 要置换的结果变量。
**'permute_fraction'** – *float [0, 1]* 要置换的行比例。

dowhy.causal_refuters.dummy_outcome_refuter.preprocess_data_by_treatment(data: DataFrame, treatment_name: List[str], unobserved_confounder_values: ndarray | None, bucket_size_scale_factor: float, chosen_variables: List[str])[source]#

此函数根据治疗的数据类型对数据进行分组。

治疗支持的预期变量类型

bool
pd.categorical
float
int

返回值:: pandas.core.groupby.generic.DataFrameGroupBy

dowhy.causal_refuters.dummy_outcome_refuter.process_data(outcome_name: str, X_train: ndarray, outcome_train: ndarray, X_validation: ndarray, outcome_validation: ndarray, transformation_list: List)[source]#

我们首先使用 X_train 和 outcome_train 训练 transformation_list 中的估计器来处理数据。然后我们将估计器应用于 X_validation 以获得虚拟结果的值，并将其存储在 outcome_validation 中。

参数:

X_train (*np.ndarray*) – 用于训练估计器的协变量数据。它对应于治疗单个类别的数据
outcome_train (*np.ndarray*) – 用于在变换列表中保存结果变量的中间值

例如

[ ('permute', {'permute_fraction': val} ), (func,func_params)]

从置换获得的值用作自定义估计器的输入。

参数:

X_validation (*np.ndarray*) – 馈送到训练好的估计器以生成虚拟结果的协变量数据
outcome_validation (*np.ndarray*) – 此变量存储由变换生成的 `dummy_outcome`
transformation_list (*np.ndarray*) – 生成虚拟结果所需的结果数据变换列表

dowhy.causal_refuters.dummy_outcome_refuter.refute_dummy_outcome(data: ~pandas.core.frame.DataFrame, target_estimand: ~dowhy.causal_identifier.identified_estimand.IdentifiedEstimand, estimate: ~dowhy.causal_estimator.CausalEstimate, treatment_name: str, outcome_name: str, required_variables: int | list | bool | None = None, min_data_point_threshold: float = 30, bucket_size_scale_factor: float = 0.5, num_simulations: int = 100, transformation_list: ~typing.List = [('zero', ''), ('noise', {'std_dev': 1})], test_fraction: ~typing.List[~dowhy.causal_refuters.dummy_outcome_refuter.TestFraction] = [TestFraction(base=0.5, other=0.5)], unobserved_confounder_values: ~typing.List | None = None, true_causal_effect: ~typing.Callable = <function <lambda>>, show_progress_bar=False, **_) → List[CausalRefutation][source]#

通过将结果替换为已知真实因果效应的模拟变量来驳斥估计。

在最简单的情况下，虚拟结果是一个独立的随机生成变量。根据定义，真实因果效应应为零。

请注意，此通用过程仅适用于后门准则。

为了防止过拟合，我们对一个 T 值拟合 f(W)，然后用它来生成其他 t 值的数据。未来将支持基于工具变量和中介的识别。

If we originally started out with

       W
    /    \
    t --->y

On estimating the following with constant t,
y_dummy = f(W)

       W
    /     \
    t --|->y

This ensures that we try to capture as much of W--->Y as possible

On adding h(t)

       W
    /    \
    t --->y
      h(t)

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 治疗名称
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
transformation_list (*list*, *可选*) –
这是一个要执行以获得结果的操作列表，默认为 `DEFAULT_TRANSFORMATION`。默认变换如下

[("zero",""),("noise", {'std_dev':1} )]

变换中的每个操作都是以下类型之一

函数参数：函数 pd.Dataframe -> np.ndarray

它接受一个将输入数据框作为输入并输出结果变量的函数。这使我们能够创建一个仅依赖于协变量而不依赖于治疗变量的输出变量。

字符串参数

目前它支持一些常用的估计器，例如

线性回归

K近邻

支持向量机

神经网络

随机森林

或诸如以下函数

置换 (Permute) 这会置换结果的行，从而解除治疗对结果的任何影响。

噪声 (Noise) 这会向结果添加白噪声，减少与治疗的因果关系。

置零 (Zero) 它将结果中的所有值替换为零

示例
`transformation_list` 具有以下形式

如果函数 pd.Dataframe -> np.ndarray 已定义。 [(func,func_params),('permute',{'permute_fraction':val}),('noise',{'std_dev':val})]

每个函数应至少支持两个参数 X_train 和 outcome_train，它们分别对应于训练数据和我们要预测的结果，同时可以通过 func_args 设置学习率或动量常数等附加参数。

[(neural_network,{'alpha': 0.0001, 'beta': 0.9}),('permute',{'permute_fraction': 0.2}),('noise',{'std_dev': 0.1})]

神经网络按 neural_network(X_train, outcome_train, **args) 调用。

如果使用上述列表中的函数 [('knn',{'n_neighbors':5}), ('permute', {'permute_fraction': val} ), ('noise', {'std_dev': val} )]

参数:: true_causal_effect – 用于获取模拟虚拟结果的真实因果效应的函数。默认为 `DEFAULT_TRUE_CAUSAL_EFFECT`，这意味着在虚拟数据中，治疗和结果之间没有关系。

注

真实因果效应的输入形状应与治疗相同，输出形状应与结果匹配

参数:: required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。

如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

注

这些输入被馈送到估计结果变量的函数。对于内部估计函数的每个实例，都使用相同的 required_variables 集。

参数:

bucket_size_scale_factor – 对于连续数据，比例因子有助于我们调整数据上使用的桶的大小。默认比例因子为 `DEFAULT_BUCKET_SCALE_FACTOR`。
min_data_point_threshold (*int*, *可选*) – 估计器运行所需的最小数据点数量。默认为 `MIN_DATA_POINT_THRESHOLD`。如果某个类别的数据点数量过少，我们将使用 `DEFAULT_TRANSFORMATION` 来生成虚拟结果

dowhy.causal_refuters.evalue_sensitivity_analyzer 模块#

class dowhy.causal_refuters.evalue_sensitivity_analyzer.EValueSensitivityAnalyzer(estimate: CausalEstimate, estimand: IdentifiedEstimand, data: DataFrame, treatment_name: str, outcome_name: str, no_effect_baseline=None)[source]#

基类: object

此类计算 Ding & VanderWeele 的 E 值，用于衡量未观测混杂。E 值是指在风险比尺度下，未观测混杂因子与治疗和结果（以观测协变量为条件）之间需要具备的最小关联强度，才能完全解释掉特定的治疗-结果关联。

它使用 McGowan 和 Greevy Jr. 的观测协变量 E 值将 E 值与观测到的混杂因子进行基准测试。此方法会丢弃观测到的混杂因子并重新拟合估计器，衡量置信区间极限界限在 E 值尺度上改变了多少。这会将假设的未观测混杂与每个观测到的混杂因子进行基准测试。

参见：https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4820664/、https://dash.harvard.edu/bitstream/handle/1/36874927/EValue_FinalSubmission.pdf 和 https://arxiv.org/pdf/2011.07030.pdf。此实现基于 R 包 cran/EValue 和 LucyMcGowan/tipr。

参数:

estimate – CausalEstimate
estimand – IdentifiedEstimand
data – pd.DataFrame
outcome_name – 结果变量名称
no_effect_baseline – 将观测估计移动到的数值。对于比率度量（RR, OR, HR），默认为 1

对于加性度量（OLS, MD），默认为 0。(Default = None)

benchmark(data: DataFrame)[source]#

使用 McGowan 和 Greevy Jr. 的观测协变量 E 值将 E 值与观测到的混杂因子进行基准测试。此方法会丢弃观测到的混杂因子并重新拟合估计器，衡量置信区间极限界限在 E 值尺度上改变了多少。这会将假设的未观测混杂与每个观测到的混杂因子进行基准测试。

参见：https://arxiv.org/pdf/2011.07030.pdf 和 https://github.com/LucyMcGowan/tipr

check_sensitivity(data: DataFrame, plot=True)[source]#

计算点估计和置信区间的 E 值。使用观测协变量 E 值将 E 值与观测到的混杂因子进行基准测试。绘制 E 值和观测协变量 E 值。

参数:: plot – 绘制点估计和置信区间的 E 值。(Default = True)

get_evalue(coef_est, coef_se)[source]#

计算点估计和置信区间的 E 值。在计算 E 值之前，将估计和置信区间转换为风险比尺度。

参数:

coef_est – 系数估计
coef_se – 系数标准误

plot(num_points_per_contour=200, plot_size=(6.4, 4.8), contour_colors=['blue', 'red'], benchmarking_color='green', xy_limit=None)[source]#

绘制等高线，显示会使点估计和置信区间倾斜的治疗-混杂因子风险比和混杂因子-结果风险比的组合。X 轴表示治疗-混杂因子风险比，Y 轴表示混杂因子-结果风险比。

参数:

num_points_per_contour – 计算和绘制每条等高线的点数 (Default = 200)
plot_size – 图形大小 (Default = (6.4,4.8))
contour_colors – 点估计和置信区间等高线的颜色 (Default = [“blue”, “red”])
benchmarking_color – 观测协变量 E 值的颜色。(Default = “green”)
xy_limit – 图形的最大 x 和 y 值。默认为 2 x E 值。(Default = None)

dowhy.causal_refuters.graph_refuter 模块#

class dowhy.causal_refuters.graph_refuter.GraphRefutation(method_name_discrete, method_name_continuous)[source]#

基类: CausalRefutation

用于存储驳斥方法结果的类。

add_conditional_independence_test_result(number_of_constraints_model, number_of_constraints_satisfied, refutation_result)[source]#

class dowhy.causal_refuters.graph_refuter.GraphRefuter(data, method_name_discrete='conditional_mutual_information', method_name_continuous='partial_correlation')[source]#

基类: CausalRefuter

用于在图上执行驳斥并存储结果的类

初始化图驳斥数据

:param data:输入数据集 :param method_name_discrete: 离散数据中条件独立性测试方法名称 :param method_name_continuous: 连续数据中条件独立性测试方法名称 :returns : GraphRefutation 类的实例

conditional_mutual_information(x=None, y=None, z=None)[source]#

partial_correlation(x=None, y=None, z=None)[source]#

refute_model(independence_constraints)[source]#

使用图驳斥对象在给定测试集上测试条件独立性的方法

参数:: independence_constraints – 用于测试条件独立性的推论列表

:returns : GraphRefutation 对象

set_refutation_result(number_of_constraints_model)[source]#: 设置图驳斥结果的方法。如果没有错误的推论，则设为 true，否则设为 false

dowhy.causal_refuters.linear_sensitivity_analyzer 模块#

class dowhy.causal_refuters.linear_sensitivity_analyzer.LinearSensitivityAnalyzer(estimator=None, data=None, treatment_name=None, percent_change_estimate=1.0, significance_level=0.05, confounder_increases_estimate=True, benchmark_common_causes=None, null_hypothesis_effect=0, frac_strength_treatment=None, frac_strength_outcome=None, common_causes_order=None)[source]#

基类: object

用于执行敏感性分析的类参见：https://carloscinelli.com/files/Cinelli%20and%20Hazlett%20(2020)%20-%20Making%20Sense%20of%20Sensitivity.pdf

参数:

estimator – 因果模型的线性估计器
data – Pandas 数据框
treatment_name –
治疗名称 :param percent_change_estimate: 这是可能改变结果的治疗估计值的减少百分比（默认值 = 1）

如果 `percent_change_estimate = 1`，则稳健性值描述了混杂因子与治疗和结果之间的关联强度，以便将估计值降低 100%，即降至 0。
null_hypothesis_effect – 零假设下的假设效应
confounder_increases_estimate – True 表示混杂因子增加了估计值的绝对值，反之亦然。(Default = True)
benchmark_common_causes – 用于限定混杂因子强度的变量名称
significance_level – 统计推断的置信区间（默认值 = 0.05）
frac_strength_treatment – 未观测混杂因子与治疗之间的关联强度，与基准协变量相比
frac_strength_outcome – 未观测混杂因子与结果之间的关联强度，与基准协变量相比
common_causes_order – OLS 回归数据中列名的顺序

check_sensitivity(plot=True)[source]#

执行敏感性分析的函数。:param plot: plot = True 生成点估计及其相对于未观测混杂变化的图。

plot = False 会覆盖此设置

返回值:: LinearSensitivityAnalyzer 类的实例

compute_bias_adjusted(r2tu_w, r2yu_tw)[source]#

计算偏差调整后的估计值、标准误、t 值、偏 R 方、置信区间

参数:

r2tu_w – 在以观测协变量 w 为条件后，将未观测混杂因子 u 对治疗 t 进行回归得到的偏 r^2
r2yu_tw – 在以观测协变量 w 和治疗 t 为条件后，将未观测混杂因子 u 对结果 y 进行回归得到的偏 r^2

返回值:

Python 字典，包含混杂因子与治疗和结果的偏 R^2 以及偏差调整变量的信息

partial_r2_func(estimator_model=None, treatment=None)[source]#

计算回归模型的偏 R^2

参数:

estimator_model – 线性回归模型
treatment – 治疗名称

返回值:

偏 R^2 值

plot(plot_type='estimate', critical_value=None, x_limit=0.8, y_limit=0.8, num_points_per_contour=200, plot_size=(7, 7), contours_color='blue', critical_contour_color='red', label_fontsize=9, contour_linewidths=0.75, contour_linestyles='solid', contours_label_color='black', critical_label_color='red', unadjusted_estimate_marker='D', unadjusted_estimate_color='black', adjusted_estimate_marker='^', adjusted_estimate_color='red', legend_position=(1.6, 0.6))[source]#

绘制并总结敏感性界限的等高线图，显示它们随未观测混杂因子与治疗和结果的偏 R^2 变化的情况。可以生成两种类型的图：基于调整后的估计值或调整后的 t 值。X 轴：治疗与未观测混杂因子(s) 的偏 R^2。Y 轴：结果与未观测混杂因子(s) 的偏 R^2。我们还绘制了从观测协变量获得的未观测混杂因子偏 R^2 的界限。

参数:

plot_type – “estimate” 或 “t-value”
critical_value – 在图表中突出显示的估计值或 t 值的特殊参考值
x_limit – 图形的最大 x 轴值（默认值 = 0.8）
y_limit – 图形的最小 y 轴值（默认值 = 0.8）
num_points_per_contour – 计算和绘制每条等高线的点数（默认值 = 200）
plot_size – 表示图形大小的元组（默认值 = (7,7)）
contours_color – 等高线的颜色（默认值 = blue）字符串或数组。如果是数组，将按升序用特定颜色绘制线条。
critical_contour_color – 阈值线的颜色（默认值 = red）
label_fontsize – 等高线标签的字体大小（默认值 = 9）
contour_linewidths – 等高线的线宽（默认值 = 0.75）
contour_linestyles – 等高线的线型（默认值 = “solid”）参见：https://matplotlib.net.cn/3.5.0/gallery/lines_bars_and_markers/linestyles.html 了解更多示例
contours_label_color – 等高线标签的颜色（默认值 = black）
critical_label_color – 阈值线标签的颜色（默认值 = red）
unadjusted_estimate_marker – 图中未经调整的估计值的标记类型（默认值 = ‘D’）参见：https://matplotlib.net.cn/stable/api/markers_api.html
adjusted_estimate_marker – 图中偏差调整估计值的标记类型（默认值 = ‘^’）

参数 unadjusted_estimate_color:

图中未经调整的估计值的标记颜色（默认值 = “black”）

参数 adjusted_estimate_color:

图中偏差调整估计值的标记颜色（默认值 = “red”）

:param legend_position:表示图例位置的元组（默认值 = (1.6, 0.6)）

treatment_regression()[source]#

执行以治疗作为结果的回归的函数

返回值:

新的 OLS 回归模型

plot_t(r2tu_w, r2yu_tw)[source]#

计算绘制 t 值的等高线、阈值线和界限。等高线（z 轴）对应于不同 r2tu_w (x) 和 r2yu_tw (y) 值的调整后 t 值。:param r2tu_w: 混杂因子与治疗的假设偏 R^2 (x 轴) :param r2yu_tw: 混杂因子与结果的假设偏 R^2 (y 轴)

返回值:

contour_values : 图表等高线的值 critical_t : 阈值点 t_bounds : 未观测混杂因子的 t 值（偏差调整后的 t 值）

robustness_value_func(alpha=1.0)[source]#

计算稳健性值的函数。这是混杂因子必须与治疗和结果具有的最小关联强度，才能改变结论。稳健性值描述了关联必须有多强才能将估计效应降低 (100 * percent_change_estimate)%。稳健性值接近 1 意味着治疗效应可以处理强的混杂因子，这些混杂因子几乎可以解释治疗和结果的所有残差变异。稳健性值接近 0 意味着即使非常弱的混杂因子也可以改变结果。

参数:: alpha – 置信区间（默认值 = 1）
返回值:: 稳健性值

treatment_regression()[source]#

执行以治疗作为结果的回归的函数

返回值:: 新的 OLS 回归模型

dowhy.causal_refuters.non_parametric_sensitivity_analyzer 模块#

class dowhy.causal_refuters.non_parametric_sensitivity_analyzer.NonParametricSensitivityAnalyzer(*args, theta_s, plugin_reisz=False, **kwargs)[source]#

基类: PartialLinearSensitivityAnalyzer

因果估计器的非参数敏感性分析。

用于估计偏差的两个重要量是 alpha 和 g。: g := E[Y | T, W, Z] 表示长回归函数 g_s := E[Y | T, W] 表示短回归函数 α := (T - E[T | W, Z] ) / (E(T - E[T | W, Z]) ^ 2) 表示长 Riesz 表示 α_s := (T - E[T | W] ) / (E(T - E[T | W]) ^ 2) 表示短 Riesz 表示

Bias = E(g_s - g)(α_s - α) 因此，界限是忽略的混杂因子在回归函数和部分线性模型的 Riesz 表示中产生的额外变异的乘积。可以写成 Bias = S * Cg * Calpha，其中 Cg 和 Calpha 是混杂因子的解释力，S^2 = E(Y - g_s) ^ 2 * E(α_s ^ 2)

基于这项工作: Chernozhukov, V., Cinelli, C., Newey, W., Sharma, A., & Syrgkanis, V. (2022). 长话短说：因果机器学习中的遗漏变量偏差 (No. w30302). National Bureau of Economic Research.

参数:

estimator – 因果模型的估计器
num_splits – 交叉验证的分裂次数。(默认值 = 5)

:param shuffle_data : 在分成折叠之前是否打乱数据 (默认值 = False) :param shuffle_random_seed: 用于随机打乱数据的种子 :param benchmark_common_causes: 用于限定混杂因素强度的变量名称 :param significance_level: 用于统计推断的置信区间 (默认值 = 0.05) :param frac_strength_treatment: 未观测混杂因素与处理之间关联强度相对于基准协变量的比例 :param frac_strength_outcome: 未观测混杂因素与结果之间关联强度相对于基准协变量的比例 :param g_s_estimator_list: 用于寻找 g_s 的估计器对象列表。这些对象应具有 fit() 和 predict() 函数。 :param g_s_estimator_param_list: 字典列表，包含用于调优“g_s_estimator_list”中相应估计器的参数。 :param alpha_s_estimator_list: 用于寻找 alpha_s 估计中使用的处理预测器的估计器对象列表。这些对象应具有 fit() 和 predict_proba() 函数。 :param alpha_s_estimator_param_list: 字典列表，包含用于调优“alpha_s_estimator_list”中相应估计器的参数。

列表中字典的顺序应与“g_s_estimator_list”中估计器对象的顺序保持一致

参数:

observed_common_causes – 已观测的共同原因的数据框
outcome – 结果数据框
treatment – 处理数据框
theta_s – 估计器的点估计
plugin_reisz – 是否使用插件 Reisz 估计器。默认为 False。插件估计器仅适用于一维二元处理。

check_sensitivity(plot=True)[source]#

执行敏感性分析的函数。以下公式用于分别获取上限和下限。 θ+ = θ_s + S * C_g * C_α θ- = θ_s - S * C_g * C_α 其中 θ_s 是获得的估计值， S^2 = E[Y - gs]^2 * E[α_s]^ 2 S 通过去偏机器学习获得。 θ_s = E[m(W, gs) + (Y - gs) * α_s] σ² = E[Y - gs]^2 ν^2 = 2 * E[m(W, α_s )] - E[α_s ^ 2]

参数:: plot – plot = True 为不同未观测混杂变化生成估计值下限图。plot = False 覆盖此设置。
返回值:: NonParametricSensitivityAnalyzer 类的实例

get_alpharegression_var(X, numeric_features, split_indices, reisz_model=None)[source]#

计算 Reisz 函数的方差

参数:

X – 包含回归变量集的 numpy 数组
split_indices – 交叉折叠后获得的训练和测试数据索引

返回值:

Reisz 函数的方差

get_phi_lower_upper(Cg, Calpha)[source]#

计算下限和上限影响函数 (phi)

参数:

Cg – 衡量遗漏变量在结果回归中产生的混杂强度的度量
Calpha – 衡量遗漏变量在处理回归中产生的混杂强度的度量

:returns : phi 的下限，phi 的上限

dowhy.causal_refuters.partial_linear_sensitivity_analyzer 模块#

class dowhy.causal_refuters.partial_linear_sensitivity_analyzer.PartialLinearSensitivityAnalyzer(estimator=None, num_splits=5, shuffle_data=False, shuffle_random_seed=None, reisz_polynomial_max_degree=3, significance_level=0.05, effect_strength_treatment=None, effect_strength_outcome=None, benchmark_common_causes=None, frac_strength_treatment=None, frac_strength_outcome=None, observed_common_causes=None, treatment=None, outcome=None, g_s_estimator_list=None, alpha_s_estimator_list=None, g_s_estimator_param_list=None, alpha_s_estimator_param_list=None, **kwargs)[source]#

基类: object

用于对偏线性模型进行敏感性分析的类。

非参数敏感性分析器的优化版本，适用于返回混杂因素对处理和结果的回归残差的估计器，例如 DML 方法。对于所有其他方法（或当偏线性假设不能保证满足时），请使用非参数敏感性分析。

基于这项工作: Chernozhukov, V., Cinelli, C., Newey, W., Sharma, A., & Syrgkanis, V. (2022). 长话短说：因果机器学习中的遗漏变量偏差 (No. w30302). National Bureau of Economic Research.

参数:

estimator – 因果模型的估计器
num_splits – 交叉验证的分裂次数。(默认值 = 5)

:param shuffle_data : 在分成折叠之前是否打乱数据 (默认值 = False) :param shuffle_random_seed: 用于随机打乱数据的种子 :param effect_strength_treatment: C^2_T，混杂因素对处理影响的合理敏感性参数列表 :param effect_strength_outcome: C^2_Y，混杂因素对结果影响的合理敏感性参数列表 :param benchmark_common_causes: 用于限定混杂因素强度的变量名称 :param significance_level: 用于统计推断的置信区间 (默认值 = 0.05) :param frac_strength_treatment: 未观测混杂因素与处理之间关联强度相对于基准协变量的比例 :param frac_strength_outcome: 未观测混杂因素与结果之间关联强度相对于基准协变量的比例 :param g_s_estimator_list: 用于寻找 g_s 的估计器对象列表。这些对象应具有 fit() 和 predict() 函数。 :param g_s_estimator_param_list: 字典列表，包含用于调优“g_s_estimator_list”中相应估计器的参数。 :param alpha_s_estimator_list: 用于寻找 alpha_s 估计中使用的处理预测器的估计器对象列表。这些对象应具有 fit() 和 predict_proba() 函数。 :param alpha_s_estimator_param_list: 字典列表，包含用于调优“alpha_s_estimator_list”中相应估计器的参数。

列表中字典的顺序应与“g_s_estimator_list”中估计器对象的顺序保持一致

参数:

observed_common_causes – 已观测的共同原因的数据框
outcome – 结果数据框
treatment – 处理数据框

calculate_robustness_value(alpha, is_partial_linear)[source]#

计算估计值对混杂因素鲁棒性值的函数 :param alpha: 用于统计推断的置信区间

返回值:: 稳健性值

check_sensitivity(plot=True)[source]#

执行敏感性分析的函数。

参数:: plot – plot = True 为不同未观测混杂变化生成估计值下限图。plot = False 覆盖此设置。
返回值:: PartialLinearSensitivityAnalyzer 类的实例

compute_r2diff_benchmarking_covariates(treatment_df, features, T, Y, W, benchmark_common_causes, split_indices=None, second_stage_linear=False, is_partial_linear=True)[source]#

计算由于未观测混杂因素的存在导致的偏 R^2 变化 :param split_indices: 交叉折叠后获得的训练和测试数据索引 :param second_stage_linear: 如果第二阶段回归是线性的则为 True，否则为 False (默认值 = False) :param is_partial_linear: 如果假设数据生成过程是偏线性的则为 True

返回 delta_r2_y_wj：: 回归方程中包含基准协变量时，结果变量解释能力的已观测加性增益
返回 delta_r2t_wj：: 回归方程中包含基准协变量时，处理变量解释能力的已观测加性增益

get_confidence_levels(r2yu_tw, r2tu_w, significance_level, is_partial_linear)[source]#

根据未观测混杂因素的不同解释能力，返回效应估计值的下限和上限。它使用以下定义。

参数:

r2yu_tw – 混杂因素对结果中残差方差的解释比例
r2tu_w – 混杂因素对处理中残差方差的解释比例
significance_level – 统计推断的置信区间（默认值 = 0.05）
is_partial_linear – 是否假设数据生成过程是偏线性的

返回 lower_confidence_bound：

估计值的置信下限

返回 upper_confidence_bound：

估计值的置信上限

返回 bias：

该混杂情景下的遗漏变量偏差

get_phi_lower_upper(Cg, Calpha)[source]#

计算下限和上限影响函数 (phi)

参数:

Cg – 衡量遗漏变量在结果回归中产生的混杂强度的度量
Calpha – 衡量遗漏变量在处理回归中产生的混杂强度的度量

:returns : phi 的下限，phi 的上限

get_regression_r2(X, Y, numeric_features, split_indices, regression_model=None)[source]#

从回归函数计算 Pearson 非参数偏 R^2。

参数:

X – 包含回归变量集的 numpy 数组
Y – 回归中的结果变量
numeric_features – 包含数值特征的列索引列表
split_indices – 交叉折叠后获得的训练和测试数据索引

返回值:

偏 R^2 值

is_benchmarking_needed()[source]#

perform_benchmarking(r2yu_tw, r2tu_w, significance_level, is_partial_linear=True)[source]#

参数:

r2yu_tw – 混杂因素对结果中残差方差的解释比例
r2tu_w – 混杂因素对处理中残差方差的解释比例
significance_level – 所需的边界显著性水平
is_partial_linear – 是否假设数据生成过程是偏线性的

返回值:

存储 r2tu_w, r2yu_tw, 短期估计, 偏差, lower_ate_bound, upper_ate_bound, lower_confidence_bound, upper_confidence_bound 值的 Python 字典

plot(plot_type='lower_confidence_bound', plot_size=(7, 7), contours_color='blue', critical_contour_color='red', label_fontsize=9, contour_linewidths=0.75, contour_linestyles='solid', contours_label_color='black', critical_label_color='red', unadjusted_estimate_marker='D', unadjusted_estimate_color='black', adjusted_estimate_marker='^', adjusted_estimate_color='red', legend_position=(1.05, 1))[source]#

参数:

plot_type – 可能的值为 ‘bias’, ‘lower_ate_bound’, ‘upper_ate_bound’, ‘lower_confidence_bound’, ‘upper_confidence_bound’
plot_size – 表示图形大小的元组（默认值 = (7,7)）
contours_color – 等高线的颜色（默认值 = blue）字符串或数组。如果是数组，将按升序用特定颜色绘制线条。
critical_contour_color – 阈值线的颜色（默认值 = red）
label_fontsize – 等高线标签的字体大小（默认值 = 9）
contour_linewidths – 等高线的线宽（默认值 = 0.75）
contour_linestyles – 等高线的线型（默认值 = “solid”）参见：https://matplotlib.net.cn/3.5.0/gallery/lines_bars_and_markers/linestyles.html 了解更多示例
contours_label_color – 等高线标签的颜色（默认值 = black）
critical_label_color – 阈值线标签的颜色（默认值 = red）
unadjusted_estimate_marker – 图中未经调整的估计值的标记类型（默认值 = ‘D’）参见：https://matplotlib.net.cn/stable/api/markers_api.html
unadjusted_estimate_color – 图中未调整估计值的标记颜色 (默认值 = “black”)
adjusted_estimate_marker – 图中偏差调整估计值的标记类型（默认值 = ‘^’）

参数 adjusted_estimate_color:

图中偏差调整估计值的标记颜色（默认值 = “red”）

:param legend_position:表示图例位置的元组（默认值 = (1.6, 0.6)）

dowhy.causal_refuters.placebo_treatment_refuter 模块#

class dowhy.causal_refuters.placebo_treatment_refuter.PlaceboTreatmentRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过用随机生成的安慰剂变量替换处理来反驳估计值。

参数:

placebo_type (str, optional) – 默认为生成处理的随机值。如果 placebo_type 为 “permute”，则按行对原始处理值进行排列。
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

refute_estimate(show_progress_bar=False)[source]#

class dowhy.causal_refuters.placebo_treatment_refuter.PlaceboType(value)[source]#

基础类：Enum

一个枚举。

DEFAULT = 'Random Data'#

PERMUTE = 'permute'#

dowhy.causal_refuters.placebo_treatment_refuter.refute_placebo_treatment(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_names: List, num_simulations: int = 100, placebo_type: PlaceboType = PlaceboType.DEFAULT, random_state: int | RandomState | None = None, show_progress_bar: bool = False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过用随机生成的安慰剂变量替换处理来反驳估计值。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_names – list: 处理名称列表
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
placebo_type – 默认为生成处理的随机值。如果 placebo_type 为 “permute”，则按行对原始处理值进行排列。
random_state – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.random_common_cause 模块#

class dowhy.causal_refuters.random_common_cause.RandomCommonCause(*args, **kwargs)[source]#

基类: CausalRefuter

通过引入随机生成的混杂因素（可能未被观测到）来反驳估计值。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。如果希望重复相同的行为，我们在伪随机生成器中推入相同的种子
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

refute_estimate(show_progress_bar=False)[source]#

dowhy.causal_refuters.random_common_cause.refute_random_common_cause(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, num_simulations: int = 100, random_state: int | RandomState | None = None, show_progress_bar: bool = False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过引入随机生成的混杂因素（可能未被观测到）来反驳估计值。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.refute_estimate 模块#

dowhy.causal_refuters.refute_estimate.refute_estimate(data: ~pandas.core.frame.DataFrame, target_estimand: ~dowhy.causal_identifier.identified_estimand.IdentifiedEstimand, estimate: ~dowhy.causal_estimator.CausalEstimate, treatment_name: str | None = None, outcome_name: str | None = None, refuters: ~typing.List[~typing.Callable[[...], ~dowhy.causal_refuter.CausalRefutation | ~typing.List[~dowhy.causal_refuter.CausalRefutation]]] = [<function sensitivity_simulation>, <function refute_bootstrap>, <function refute_data_subset>, <function refute_dummy_outcome>, <function refute_placebo_treatment>, <function refute_random_common_cause>], **kwargs) → List[CausalRefutation][source]#

使用默认参数执行反驳器列表: 仅支持返回 CausalRefutation 或 CausalRefutation 列表的反驳器

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 处理名称 (可选)
outcome_name – str: 结果名称 (可选)
refuters – list: 要执行的反驳器列表

**kwargskwargs：

替换提供的反驳器列表的任何默认值

dowhy.causal_refuters.reisz 模块#

class dowhy.causal_refuters.reisz.PluginReisz(propensity_model)[source]#

基类: object

用于平均处理效应的插件 Reisz 函数

fit(X)[source]#

predict(X)[source]#

propensity(X)[source]#: P(T=1|W)

class dowhy.causal_refuters.reisz.ReiszRepresenter(*args: Any, **kwargs: Any)[source]#

基础类：BaseGRF

广义随机森林 (GRF) 用于估计 Reisz Representer (RR) 参见：microsoft/EconML :param reisz_functions: 使用 create_polynomial_function 创建的 n 次多项式函数列表，用于近似 Reisz Representer :param moment_function: 用于计算估计值的期望值矩函数 m(W,g) :param l2_regularizer: 建模时的 l2 惩罚项 (默认值 = 1e-3) 关于调整其他参数，请参见 https://econml.dowhy.cn/_autosummary/econml.grf.CausalForest.html

fit(X)[source]#

predict(X_test)[source]#

dowhy.causal_refuters.reisz.get_alpha_estimator(cv, X, max_degree=None, estimator_list=None, estimator_param_list=None, numeric_features=None, plugin_reisz=True)[source]#

为 Reisz Representer (alpha_s) 找到最佳估计器

参数:

cv – 对数据集进行 K 折叠后获得的训练和测试数据索引
X – 处理变量 + 混杂因素
max_degree – 用于近似 alpha_s 的多项式函数的次数
param_grid_dict – 包含用于调优 ReiszRepresenter 估计器的参数的 Python 字典

返回值:

alpha_s 的估计器

此方法假设 T 是二元的。

dowhy.causal_refuters.reisz.get_generic_regressor(cv, X, Y, max_degree=3, estimator_list=None, estimator_param_list=None, numeric_features=None)[source]#

为回归函数 (g_s) 找到最佳估计器

参数:

cv – 对数据集进行 K 折叠后获得的训练和测试数据索引
X – 用于训练回归模型的回归变量数据
Y – 用于训练回归模型的结果数据
max_degree – 用于近似回归函数的多项式函数的次数
estimator_list – 用于寻找回归函数的估计器对象列表
estimator_param_list – 字典列表，包含用于调优 estimator_list 中相应估计器的参数
numeric_features – 数据集中数值特征的索引列表

返回值:

Reisz 回归函数的估计器

dowhy.causal_refuters.reisz.reisz_scoring(g, X)[source]#

返回估计器模型的损失 :param g: 要评估的模型 :param X: 用于测试模型的数据

返回值:: 量化模型预测的浮点数

Loss(g) = E[2*m(X,g) - g(X)**2]

模块内容#

class dowhy.causal_refuters.AddUnobservedCommonCause(*args, **kwargs)[source]#

基类: CausalRefuter

添加一个未观测到的混杂因素进行反驳。

AddUnobservedCommonCause 类支持三种方法

模拟一个未观测到的混杂因素
线性偏 R2：线性模型的敏感性分析。
基于非参数偏 R2：非参数模型的敏感性分析。

支持可在 refute_estimate() 方法中指定的附加参数。

初始化反驳器所需的参数。

参数:

simulation_method – 用于模拟未观测到的混杂因素效应的方法。可能的值包括 [“direct-simulation”, “linear-partial-R2”, “non-parametric-partial-R2”, “e-value”]。
confounders_effect_on_treatment – str : 未观测到的混杂因素对治疗产生的效应类型。可能的值包括 ['binary_flip', 'linear']
confounders_effect_on_outcome – str : 未观测到的混杂因素对结果产生的效应类型。可能的值包括 ['binary_flip', 'linear']
effect_strength_on_treatment – float, numpy.ndarray: [当 simulation_method=”direct-simulation” 时使用] 混杂因素对治疗的效应强度。当 confounders_effect_on_treatment 是线性时，它是回归系数。当 confounders_effect_on_treatment 是二元翻转时，它是未观测到的混杂因素效应可以反转治疗值的概率。
effect_strength_on_outcome – float, numpy.ndarray: 混杂因素对结果的效应强度。其解释取决于 confounders_effect_on_outcome 和 simulation_method。当 simulation_method 是 direct-simulation 时，对于线性效应，其行为类似于回归系数；对于二元翻转，它是它可以反转结果值的概率。
partial_r2_confounder_treatment – float, numpy.ndarray: [当 simulation_method 是 linear-partial-R2 或 non-parametric-partial-R2 时使用] 未观测到的混杂因素相对于以观测到的混杂因素为条件的治疗的偏 R2。仅在一般 non-parametric-partial-R2 的情况下，它是未观测到的混杂因素解释的 reisz representer 的方差比例；具体来说是 (1-r)，其中 r 是基于观测到的混杂因素和基于所有混杂因素的 reisz representer (alpha^2) 方差之比。
partial_r2_confounder_outcome – float, numpy.ndarray: [当 simulation_method 是 linear-partial-R2 或 non-parametric-partial-R2 时使用] 未观测到的混杂因素相对于以治疗和观测到的混杂因素为条件的结果的偏 R2。
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
plotmethod – string: 要显示的图表类型。如果为 None，则不生成图表。仅当提供了多个治疗混杂因素效应值或结果混杂因素效应值时才使用此参数。默认值为“colormesh”。当两个混杂因素效应值参数都提供了多个值时，支持的值为“contour”，“colormesh”；仅提供其中一个时，支持的值为“line”。
percent_change_estimate – 这是可能改变结果的治疗估计值减少百分比（默认值 = 1）。如果 percent_change_estimate = 1，则稳健性值描述了混杂因素与治疗和结果关联的强度，以便将估计值降低 100%，即降至 0。（仅与线性敏感性分析相关，其余情况忽略）
confounder_increases_estimate – True 表示混杂因素增加了估计值的绝对值，反之亦然。（默认值 = False）。（仅与线性敏感性分析相关，其余情况忽略）
benchmark_common_causes – 用于限定混杂因素强度的变量名称。（仅与基于偏 R2 的模拟方法相关）
significance_level – 统计推断的置信区间（默认值 = 0.05）。（仅与基于偏 R2 的模拟方法相关）
null_hypothesis_effect – 零假设下的假定效应。（仅与 linear-partial-R2 相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计值的等高线图。（默认值 = True）。（仅与基于偏 R2 的模拟方法相关）
num_splits – 交叉验证的分裂次数。（默认值 = 5）。（仅与 non-parametric-partial-R2 模拟方法相关）

include_simulated_confounder(convergence_threshold=0.1, c_star_max=1000)[source]#

refute_estimate(show_progress_bar=False)[source]#

class dowhy.causal_refuters.BootstrapRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过在包含混杂因子测量误差的数据随机样本上运行估计来驳斥估计。这允许我们找到估计器找出治疗对结果影响的能力。

它支持可以在 refute_estimate() 方法中指定的附加参数。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
sample_size (*int*, *可选*) – 每个自举样本的大小，默认为原始数据的大小
required_variables (*int*, *list*, *bool*, *可选*) – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

整数参数指定用于估计结果值的变量数量
列表参数显式指定用于估计结果的变量。此外，它还提供了显式选择或取消选择结果估计中存在的协变量的能力。这可以通过如下所示的从列表中添加或显式删除变量来实现

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。
如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

参数:

noise (*float*, *可选*) – 添加到数据的噪声的标准差，默认为 `BootstrapRefuter.DEFAULT_STD_DEV`
probability_of_change (*float*, *可选*) – 指定更改布尔或分类变量数据的概率。默认为 `noise`，仅当 `noise` 的值小于 1 时。
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。

DEFAULT_NUMBER_OF_TRIALS = 1#

DEFAULT_STD_DEV = 0.1#

DEFAULT_SUCCESS_PROBABILITY = 0.5#

refute_estimate(show_progress_bar: bool = False, *args, **kwargs)[source]#

class dowhy.causal_refuters.DataSubsetRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过在原始数据的随机子集上重新运行估计来驳斥估计。

参数:

subset_fraction (*float*, *可选*) – 用于重新估计的数据比例，默认为 `DataSubsetRefuter.DEFAULT_SUBSET_FRACTION`。
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。如果希望重复相同的行为，我们在伪随机生成器中推入相同的种子
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

DEFAULT_SUBSET_FRACTION = 0.8#

refute_estimate(show_progress_bar: bool =False)[source]#

class dowhy.causal_refuters.DummyOutcomeRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过将结果替换为已知真实因果效应的模拟变量来驳斥估计。

在最简单的情况下，虚拟结果是一个独立的随机生成变量。根据定义，真实因果效应应为零。

请注意，此通用过程仅适用于后门准则。

为了防止过拟合，我们对一个 T 值拟合 f(W)，然后用它来生成其他 t 值的数据。未来将支持基于工具变量和中介的识别。

If we originally started out with

       W
    /    \
    t --->y

On estimating the following with constant t,
y_dummy = f(W)

       W
    /     \
    t --|->y

This ensures that we try to capture as much of W--->Y as possible

On adding h(t)

       W
    /    \
    t --->y
      h(t)

支持可在 refute_estimate() 方法中指定的附加参数。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
transformation_list (*list*, *可选*) –
这是一个要执行以获得结果的操作列表，默认为 `DEFAULT_TRANSFORMATION`。默认变换如下

[("zero",""),("noise", {'std_dev':1} )]

变换中的每个操作都是以下类型之一

函数参数：函数 pd.Dataframe -> np.ndarray

它接受一个将输入数据框作为输入并输出结果变量的函数。这使我们能够创建一个仅依赖于协变量而不依赖于治疗变量的输出变量。

字符串参数

目前它支持一些常用的估计器，例如

线性回归

K近邻

支持向量机

神经网络

随机森林

或诸如以下函数

置换 (Permute) 这会置换结果的行，从而解除治疗对结果的任何影响。

噪声 (Noise) 这会向结果添加白噪声，减少与治疗的因果关系。

置零 (Zero) 它将结果中的所有值替换为零

示例
`transformation_list` 具有以下形式

如果函数 pd.Dataframe -> np.ndarray 已定义。 [(func,func_params),('permute',{'permute_fraction':val}),('noise',{'std_dev':val})]

每个函数应至少支持两个参数 X_train 和 outcome_train，它们分别对应于训练数据和我们要预测的结果，同时可以通过 func_args 设置学习率或动量常数等附加参数。

[(neural_network,{'alpha': 0.0001, 'beta': 0.9}),('permute',{'permute_fraction': 0.2}),('noise',{'std_dev': 0.1})]

神经网络按 neural_network(X_train, outcome_train, **args) 调用。

如果使用上述列表中的函数 [('knn',{'n_neighbors':5}), ('permute', {'permute_fraction': val} ), ('noise', {'std_dev': val} )]

参数:: true_causal_effect – 用于获取模拟虚拟结果的真实因果效应的函数。默认为 `DEFAULT_TRUE_CAUSAL_EFFECT`，这意味着在虚拟数据中，治疗和结果之间没有关系。

注

真实因果效应的输入形状应与治疗相同，输出形状应与结果匹配

参数:: required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。

如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

注

这些输入被馈送到估计结果变量的函数。对于内部估计函数的每个实例，都使用相同的 required_variables 集。

参数:

bucket_size_scale_factor – 对于连续数据，比例因子有助于我们调整数据上使用的桶的大小。默认比例因子为 `DEFAULT_BUCKET_SCALE_FACTOR`。
min_data_point_threshold (*int*, *可选*) – 估计器运行所需的最小数据点数量。默认为 `MIN_DATA_POINT_THRESHOLD`。如果某个类别的数据点数量过少，我们将使用 `DEFAULT_TRANSFORMATION` 来生成虚拟结果

refute_estimate(show_progress_bar: bool =False)[source]#

class dowhy.causal_refuters.PlaceboTreatmentRefuter(*args, **kwargs)[source]#

基类: CausalRefuter

通过用随机生成的安慰剂变量替换处理来反驳估计值。

参数:

placebo_type (str, optional) – 默认为生成处理的随机值。如果 placebo_type 为 “permute”，则按行对原始处理值进行排列。
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

refute_estimate(show_progress_bar=False)[source]#

class dowhy.causal_refuters.RandomCommonCause(*args, **kwargs)[source]#

基类: CausalRefuter

通过引入随机生成的混杂因素（可能未被观测到）来反驳估计值。

参数:

num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state (*int*, *RandomState*, *可选*) – 如果希望重复相同的随机行为，要添加的种子值。如果希望重复相同的行为，我们在伪随机生成器中推入相同的种子
n_jobs (*int*, *可选*) – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose (*int*, *可选*) – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

refute_estimate(show_progress_bar=False)[source]#

dowhy.causal_refuters.refute_bootstrap(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, num_simulations: int = 100, random_state: int | RandomState | None = None, sample_size: int | None = None, required_variables: bool =True, noise: float =0.1, probability_of_change: float | None =None, show_progress_bar: bool =False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过在包含混杂因子测量误差的数据随机样本上运行估计来驳斥估计。这允许我们找到估计器找出治疗对结果影响的能力。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
num_simulations – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。
sample_size – 每个自举样本的大小，默认为原始数据的大小
required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

整数参数指定用于估计结果值的变量数量
列表参数显式指定用于估计结果的变量。此外，它还提供了显式选择或取消选择结果估计中存在的协变量的能力。这可以通过如下所示的从列表中添加或显式删除变量来实现

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。
如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

默认为 `noise`，仅当 `noise` 的值小于 1 时。

参数:

n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.refute_data_subset(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, subset_fraction: float = 0.8, num_simulations: int = 100, random_state: int | RandomState | None = None, show_progress_bar: bool =False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过在原始数据的随机子集上重新运行估计来驳斥估计。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
subset_fraction – 用于重新估计的数据比例，默认为 `DataSubsetRefuter.DEFAULT_SUBSET_FRACTION`。
num_simulations – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
random_state – 如果希望重复相同的随机行为，要添加的种子值。为此，我们在伪随机生成器中使用相同的种子。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.refute_dummy_outcome(data: ~pandas.core.frame.DataFrame, target_estimand: ~dowhy.causal_identifier.identified_estimand.IdentifiedEstimand, estimate: ~dowhy.causal_estimator.CausalEstimate, treatment_name: str, outcome_name: str, required_variables: int | list | bool | None = None, min_data_point_threshold: float = 30, bucket_size_scale_factor: float = 0.5, num_simulations: int = 100, transformation_list: ~typing.List = [('zero', ''), ('noise', {'std_dev': 1})], test_fraction: ~typing.List[~dowhy.causal_refuters.dummy_outcome_refuter.TestFraction] = [TestFraction(base=0.5, other=0.5)], unobserved_confounder_values: ~typing.List | None = None, true_causal_effect: ~typing.Callable = <function <lambda>>, show_progress_bar=False, **_) → List[CausalRefutation][source]#

通过将结果替换为已知真实因果效应的模拟变量来驳斥估计。

在最简单的情况下，虚拟结果是一个独立的随机生成变量。根据定义，真实因果效应应为零。

请注意，此通用过程仅适用于后门准则。

为了防止过拟合，我们对一个 T 值拟合 f(W)，然后用它来生成其他 t 值的数据。未来将支持基于工具变量和中介的识别。

If we originally started out with

       W
    /    \
    t --->y

On estimating the following with constant t,
y_dummy = f(W)

       W
    /     \
    t --|->y

This ensures that we try to capture as much of W--->Y as possible

On adding h(t)

       W
    /    \
    t --->y
      h(t)

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 治疗名称
num_simulations (*int*, *可选*) – 要运行的模拟次数，默认为 `CausalRefuter.DEFAULT_NUM_SIMULATIONS`
transformation_list (*list*, *可选*) –
这是一个要执行以获得结果的操作列表，默认为 `DEFAULT_TRANSFORMATION`。默认变换如下

[("zero",""),("noise", {'std_dev':1} )]

变换中的每个操作都是以下类型之一

函数参数：函数 pd.Dataframe -> np.ndarray

它接受一个将输入数据框作为输入并输出结果变量的函数。这使我们能够创建一个仅依赖于协变量而不依赖于治疗变量的输出变量。

字符串参数

目前它支持一些常用的估计器，例如

线性回归

K近邻

支持向量机

神经网络

随机森林

或诸如以下函数

置换 (Permute) 这会置换结果的行，从而解除治疗对结果的任何影响。

噪声 (Noise) 这会向结果添加白噪声，减少与治疗的因果关系。

置零 (Zero) 它将结果中的所有值替换为零

示例
`transformation_list` 具有以下形式

如果函数 pd.Dataframe -> np.ndarray 已定义。 [(func,func_params),('permute',{'permute_fraction':val}),('noise',{'std_dev':val})]

每个函数应至少支持两个参数 X_train 和 outcome_train，它们分别对应于训练数据和我们要预测的结果，同时可以通过 func_args 设置学习率或动量常数等附加参数。

[(neural_network,{'alpha': 0.0001, 'beta': 0.9}),('permute',{'permute_fraction': 0.2}),('noise',{'std_dev': 0.1})]

神经网络按 neural_network(X_train, outcome_train, **args) 调用。

如果使用上述列表中的函数 [('knn',{'n_neighbors':5}), ('permute', {'permute_fraction': val} ), ('noise', {'std_dev': val} )]

参数:: true_causal_effect – 用于获取模拟虚拟结果的真实因果效应的函数。默认为 `DEFAULT_TRUE_CAUSAL_EFFECT`，这意味着在虚拟数据中，治疗和结果之间没有关系。

注

真实因果效应的输入形状应与治疗相同，输出形状应与结果匹配

参数:: required_variables – 用作 `y~f(W)` 输入的变量列表。默认为 `True`，这会选择除治疗和结果之外的所有变量

注

如果需要 `W0` 和 `W1`，则需要传入 `required_variables = [W0,W1]`。

如果需要除 `W0` 和 `W1` 之外的所有变量，则需要传入 `required_variables = [-W0,-W1]`。

如果值为 `True`，则希望包含所有变量来估计结果值。

警告

`False` 值是 `INVALID` 的，将导致 `error`。

注

这些输入被馈送到估计结果变量的函数。对于内部估计函数的每个实例，都使用相同的 required_variables 集。

参数:

bucket_size_scale_factor – 对于连续数据，比例因子有助于我们调整数据上使用的桶的大小。默认比例因子为 `DEFAULT_BUCKET_SCALE_FACTOR`。
min_data_point_threshold (*int*, *可选*) – 估计器运行所需的最小数据点数量。默认为 `MIN_DATA_POINT_THRESHOLD`。如果某个类别的数据点数量过少，我们将使用 `DEFAULT_TRANSFORMATION` 来生成虚拟结果

dowhy.causal_refuters.refute_estimate(data: ~pandas.core.frame.DataFrame, target_estimand: ~dowhy.causal_identifier.identified_estimand.IdentifiedEstimand, estimate: ~dowhy.causal_estimator.CausalEstimate, treatment_name: str | None = None, outcome_name: str | None = None, refuters: ~typing.List[~typing.Callable[[...], ~dowhy.causal_refuter.CausalRefutation | ~typing.List[~dowhy.causal_refuter.CausalRefutation]]] = [<function sensitivity_simulation>, <function refute_bootstrap>, <function refute_data_subset>, <function refute_dummy_outcome>, <function refute_placebo_treatment>, <function refute_random_common_cause>], **kwargs) → List[CausalRefutation][source]#

使用默认参数执行反驳器列表: 仅支持返回 CausalRefutation 或 CausalRefutation 列表的反驳器

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 处理名称 (可选)
outcome_name – str: 结果名称 (可选)
refuters – list: 要执行的反驳器列表

**kwargskwargs：

替换提供的反驳器列表的任何默认值

dowhy.causal_refuters.refute_placebo_treatment(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_names: List, num_simulations: int = 100, placebo_type: PlaceboType = PlaceboType.DEFAULT, random_state: int | RandomState | None = None, show_progress_bar: bool =False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[source]#

通过用随机生成的安慰剂变量替换处理来反驳估计值。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_names – list: 处理名称列表
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
placebo_type – 默认为生成处理的随机值。如果 placebo_type 为 “permute”，则按行对原始处理值进行排列。
random_state – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.refute_random_common_cause(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, num_simulations: int = 100, random_state: int | RandomState | None = None, show_progress_bar: bool = False, n_jobs: int = 1, verbose: int = 0, **_) → CausalRefutation[源代码]#

通过引入随机生成的混杂因素（可能未被观测到）来反驳估计值。

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想重复相同的行为，则将相同的种子推入伪随机生成器。
n_jobs – 最大并发运行作业数。如果为 -1，则使用所有 CPU。如果为 1，则根本不使用并行计算代码（这是默认值）。
verbose – 详细程度级别：如果非零，将打印进度消息。高于 50 时，输出将发送到标准输出。消息频率随详细程度级别增加。如果大于 10，将报告所有迭代。默认为 0。

dowhy.causal_refuters.sensitivity_e_value(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_name: List[str], outcome_name: List[str], plot_estimate: bool = True) → EValueSensitivityAnalyzer[源代码]#

dowhy.causal_refuters.sensitivity_simulation(data: DataFrame, target_estimand: IdentifiedEstimand, estimate: CausalEstimate, treatment_name: str, outcome_name: str, kappa_t: float | ndarray | None = None, kappa_y: float | ndarray | None = None, confounders_effect_on_treatment: str = 'binary_flip', confounders_effect_on_outcome: str = 'linear', frac_strength_treatment: float = 1.0, frac_strength_outcome: float = 1.0, plotmethod: str | None = None, show_progress_bar=False, **_) → CausalRefutation[源代码]#

参数:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计目标
estimate – CausalEstimate: 用于运行反驳的估计值
treatment_name – str: 治疗名称
outcome_name – str: 结果名称
kappa_t – float, numpy.ndarray: 混杂因素对治疗的效应强度。当 confounders_effect_on_treatment 是线性时，它是回归系数。当 confounders_effect_on_treatment 是二元翻转时，它是未观测到的混杂因素效应可以反转治疗值的概率。
kappa_y – float, numpy.ndarray: 混杂因素对结果的效应强度。其解释取决于 confounders_effect_on_outcome 和 simulation_method。当 simulation_method 是 direct-simulation 时，对于线性效应，其行为类似于回归系数；对于二元翻转，它是它可以反转结果值的概率。
confounders_effect_on_treatment – str : 未观测到的混杂因素对治疗产生的效应类型。可能的值包括 ['binary_flip', 'linear']
confounders_effect_on_outcome – str : 未观测到的混杂因素对结果产生的效应类型。可能的值包括 ['binary_flip', 'linear']
frac_strength_treatment – float: 此参数决定了模拟混杂因素对治疗的效应强度，其值为观测到的混杂因素对治疗的效应强度的一部分。默认为 1。
frac_strength_outcome – float: 此参数决定了模拟混杂因素对结果的效应强度，其值为观测到的混杂因素对结果的效应强度的一部分。默认为 1。
plotmethod – string: 要显示的图表类型。如果为 None，则不生成图表。仅当提供了多个治疗混杂因素效应值或结果混杂因素效应值时才使用此参数。默认值为“colormesh”。当两个混杂因素效应值参数都提供了多个值时，支持的值为“contour”，“colormesh”；仅提供其中一个时，支持的值为“line”。

返回值:

CausalRefuter: 包含估计效应、新效应以及使用的反驳方法名称的对象。

dowhy.causal_refuters 包#

子包#

子模块#

dowhy.causal_refuters.add_unobserved_common_cause 模块#

dowhy.causal_refuters.assess_overlap 模块#

dowhy.causal_refuters.assess_overlap_overrule 模块#

dowhy.causal_refuters.bootstrap_refuter 模块#

dowhy.causal_refuters.data_subset_refuter 模块#

dowhy.causal_refuters.dummy_outcome_refuter 模块#

dowhy.causal_refuters.evalue_sensitivity_analyzer 模块#

dowhy.causal_refuters.graph_refuter 模块#

dowhy.causal_refuters.linear_sensitivity_analyzer 模块#

dowhy.causal_refuters.non_parametric_sensitivity_analyzer 模块#

dowhy.causal_refuters.partial_linear_sensitivity_analyzer 模块#

dowhy.causal_refuters.placebo_treatment_refuter 模块#

dowhy.causal_refuters.random_common_cause 模块#

dowhy.causal_refuters.refute_estimate 模块#

dowhy.causal_refuters.reisz 模块#

模块内容#