dowhy.causal_refuters 包#

子模块#

dowhy.causal_refuters.add_unobserved_common_cause 模块#

class dowhy.causal_refuters.add_unobserved_common_cause.AddUnobservedCommonCause(*args, **kwargs)[源代码]#

基础类：CausalRefuter

为反驳添加一个未观察到的混淆因素。

AddUnobservedCommonCause class supports three methods:

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

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

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

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

Parameters:

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表示器的方差比例；具体来说，是(1-r)，其中r是基于已观察到的混杂变量的reisz表示器的方差比，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）。（仅适用于基于partial-r2的模拟方法）
null_hypothesis_effect – 零假设下的假定效应。（仅与linear-partial-R2相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计的等高线图。（默认 = True）。（仅适用于基于partial-r2的模拟方法）
num_splits – 交叉验证的分割次数。（默认值 = 5）。（仅适用于非参数部分R2模拟方法）

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

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

refute_estimate(show_progress_bar=False)[源代码]#

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. 权重的比例应使它们在某些置信区间内保持最大可能观察到的系数的比例

Parameters:

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

Returns:

基于数据的未观测混杂因素的模拟值 :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. 标准化。

Parameters:

data – 所有数据，其中一些需要预处理。
target_estimand – 期望效果的估计量，包括后门变量的定义。
no_common_causes_error_message – 如果没有后门变量存在时，与ValueError一起显示的消息。

Returns:

包含预处理数据的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方法（线性模型的敏感性分析）添加一个未观察到的混杂因素进行反驳。

Parameters:

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）。（仅适用于基于partial-r2的模拟方法）
null_hypothesis_effect – 零假设下的假定效应。（仅与linear-partial-R2相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计的等高线图。（默认 = True）。（仅适用于基于partial-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方法（非参数模型的敏感性分析）添加一个未观察到的混杂因素进行反驳。

Parameters:

estimate – CausalEstimate: 用于运行反驳的估计
kappa_t – float, numpy.ndarray: 未观察到的混杂因素相对于治疗的偏R2，条件是观察到的混杂因素。仅在一般非参数偏R2的情况下，它是未观察到的混杂因素解释的reisz表示器的方差分数；具体来说，是(1-r)，其中r是基于观察到的混杂因素的reisz表示器的方差比，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）。（仅适用于基于partial-r2的模拟方法）
alpha_s_estimator_list – 用于估计alpha_s的估计器对象列表。这些对象应具有fit()和predict()方法（仅适用于非参数部分R2方法）
alpha_s_estimator_param_list – 用于查找alpha_s的参数字典列表。（仅适用于非参数部分R2模拟方法）
g_s_estimator_list – 用于寻找g_s的估计器对象列表。这些对象应实现fit()和predict()函数。（仅适用于非参数部分R2模拟方法）
g_s_estimator_param_list – 包含用于调整“g_s_estimator_list”中相应估计器参数的字典列表。列表中的字典顺序应与“g_s_estimator_list”中的估计器对象顺序一致。（仅适用于非参数部分R2模拟方法）

Plugin_reisz:

bool: 标志，用于确定是否使用插件估计器或非参数估计器来计算reisz表示函数（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]#

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

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
treatment_name – str: 处理的名称
outcome_name – str: 结果的名称
kappa_t – float, numpy.ndarray: 混杂因素对治疗影响的强度。当混杂因素对治疗的影响是线性时，它是回归系数。当混杂因素对治疗的影响是二元翻转时，它是未观察到的混杂因素可以反转治疗值的概率。
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”。

Returns:

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). 观察研究中的重叠特征。在 S. Chiappa & R. Calandra (Eds.), 第二十三届国际人工智能与统计会议论文集 (Vol. 108, pp. 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()获取后门变量集。

Param:: cat_feats: List[str]: 分类特征列表，所有其他特征将被离散化
Param:: support_config: SupportConfig: 用于学习支持规则的配置选项的数据类
Param:: overlap_config: OverlapConfig: 用于学习重叠规则的配置选项的数据类
Param:: overlap_eps: float: 定义一个点在重叠区域中被考虑的倾向得分范围，范围定义为 (overlap_eps, 1 - overlap_eps)，默认值为 0.1
Param:: overrule_verbose: bool: 启用优化输出的详细日志记录，默认为 False
Param:: support_only: bool: 仅拟合规则以描述支持区域（不拟合重叠规则），默认为 False
Param:: overlap_only: bool: 仅拟合规则以描述重叠区域（不拟合支持规则），默认为 False

refute_estimate(show_progress_bar=False)[source]#

学习重叠和支持规则。

Parameters:: show_progress_bar (bool) – 未实现，如果设置为True将会引发错误，默认为False
Raises:: NotImplementedError – 如果 show_progress_bar=True，将会引发此错误
Returns:: 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学习支持和重叠规则。

Parameters:

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

Param:: support_only: bool: 仅拟合支持区域
Param:: overlap_only: bool: 仅拟合重叠区域
Param:: 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

学习重叠规则的配置。

Parameters:

alpha (float, optional) – 确保包含在规则中的重叠样本的比例，默认为0.95
lambda0 (float, 可选) – 规则数量的正则化，默认为 1e-3
lambda1 (float, optional) – 正则化项，用于控制字面量的数量，默认值为 1e-3
K (int, optional) – 在束搜索期间返回的最大结果数，默认为20
D (int, 可选) – 每次束搜索迭代的最大额外规则数，默认为20
B (int, optional) – 光束搜索的宽度，默认为10
iterMax (int, 可选) – 列生成的最大迭代次数，默认为10
num_thresh (int, optional) – 用于离散化连续变量的分箱数量，默认为9（用于十分位数）
thresh_override (可选[字典], 可选) – 手动覆盖连续特征的阈值，以如下字典形式给出，仅适用于具有超过num_thresh唯一值的连续特征 thresh_override = {column_name: np.linspace(0, 100, 10)}
solver (str, optional) – CVXPY 用于解决线性规划松弛的线性规划求解器，默认为‘ECOS’
rounding (str, optional) – 执行舍入的策略，可以是‘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

学习支持和重叠规则。

Parameters:: backdoor_vars – 后门变量列表。支持和重叠规则将仅针对这些变量进行学习。

这些变量 :type backdoor_vars: List[str] :param treatment_name: 处理名称 :type treatment_name: str :param: cat_feats: List[str]: 分类特征列表，其他特征将被离散化 :param: support_config: SupportConfig: 包含学习支持规则配置选项的数据类 :param: overlap_config: OverlapConfig: 包含学习重叠规则配置选项的数据类 :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

Parameters:

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

describe_all_rules()[source]#

describe_overlap_rules()[source]#

describe_support_rules()[source]#

filter_dataframe(data: DataFrame)[来源]#

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

学习支持规则的配置。

Parameters:

n_ref_multiplier (float, optional) – 参考样本计数乘数，默认为1.0
seed (int, optional) – 用于参考样本的随机种子，仅用于估计支持度，默认为 None
alpha (float, optional) – 确保包含在规则中的现有示例的比例，默认为 0.98
lambda0 (float, optional) – 规则数量的正则化，默认为 1e-2
lambda1 (float, optional) – 正则化项，用于控制字面量的数量，默认值为 1e-3
K (int, optional) – 在束搜索期间返回的最大结果数，默认为20
D (int, 可选) – 每次束搜索迭代的最大额外规则数，默认为20
B (int, optional) – 光束搜索的宽度，默认为10
iterMax (int, 可选) – 列生成的最大迭代次数，默认为10
num_thresh (int, optional) – 用于离散化连续变量的分箱数量，默认为9（用于十分位数）
thresh_override (可选[字典], 可选) – 手动覆盖连续特征的阈值，以如下字典形式给出，仅适用于具有超过num_thresh唯一值的连续特征 thresh_override = {column_name: np.linspace(0, 100, 10)}
solver (str, optional) – CVXPY 用于解决线性规划松弛的线性规划求解器，默认为‘ECOS’
rounding (str, optional) – 执行舍入的策略，可以是‘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()方法中指定的额外参数。

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
sample_size (int, optional) – 每个引导样本的大小，默认情况下是原始数据的大小
required_variables (int, list, bool, optional) – 用作y~f(W)输入的变量列表默认情况下为True，这将选择所有变量，排除处理和结果

一个整数参数指的是将使用多少个变量来估计结果的值
一个列表明确指出了哪些变量将用于估计结果此外，它还提供了明确选择或取消选择在结果估计中存在的协变量的能力。这是通过添加或明确从列表中移除变量来实现的，如下所示：

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。
如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

Parameters:

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

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]#

通过在包含混杂因素测量误差的数据的随机样本上运行估计来反驳估计。这使我们能够找到估计器发现治疗对结果影响的能力。

Parameters:

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，我们希望包含所有变量来估计结果的值。 .. 警告:: False 值是 INVALID 并且会导致 error。 :param noise: 要添加到数据中的噪声的标准差，默认为 BootstrapRefuter.DEFAULT_STD_DEV :param probability_of_change: 它指定了我们改变布尔或分类变量数据的概率

默认情况下是noise，只有当noise的值小于1时。

Parameters:

n_jobs – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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）。

Parameters:

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

DEFAULT_SUBSET_FRACTION = 0.8#

refute_estimate(show_progress_bar: bool = False)[源代码]#

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]#

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

Parameters:

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时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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) 只是为模拟结果定义了一个新的数据生成过程，它不需要是从 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() 方法中指定的附加参数。

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
transformation_list (list, optional) –
这是一个要执行的操作列表，用于获得结果，默认为 DEFAULT_TRANSFORMATION。默认的转换如下：

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

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

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

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

字符串参数

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

线性回归

K近邻

支持向量机

神经网络

随机森林

或者函数如：

Permute 这会对结果的行进行排列，消除治疗对结果的任何影响。

Noise 这会在结果中添加白噪声，减少与治疗的任何因果关系。

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

Examples:
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} )]

Parameters:: true_causal_effect – 一个用于获取模拟结果的真实因果效应的函数。它默认为 DEFAULT_TRUE_CAUSAL_EFFECT，这意味着在模拟数据中，处理和结果之间没有关系。

注意

真正的因果效应应该接受与处理相同形状的输入，并且输出应该与结果的形状匹配

Parameters:: required_variables – 用作y~f(W)输入的变量列表默认情况下，这是True，从而选择除处理和结果之外的所有变量

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。

如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

注意

这些输入被提供给函数以估计结果变量。每个内部估计函数的实例都使用相同的required_variables集合。

Parameters:

bucket_size_scale_factor – 对于连续数据，比例因子帮助我们缩放用于数据的桶的大小。默认比例因子是 DEFAULT_BUCKET_SCALE_FACTOR。
min_data_point_threshold (int, optional) – 估计器运行所需的最小数据点数。默认值为 MIN_DATA_POINT_THRESHOLD。如果某个类别的数据点太少，我们将使用 DEFAULT_TRANSFORMATION 来生成虚拟结果。

refute_estimate(show_progress_bar: bool = False)[源代码]#

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的白噪声

Parameters:

'outcome' – np.ndarray 结果变量，白噪声被添加到该变量中。
'std_dev' – float 白噪声的标准差。

Returns:

添加噪声后的结果

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。

Parameters:

'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]#

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

治疗支持的预期变量类型：

布尔值
pd.categorical
浮点数
整数

Returns:: 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中。

Parameters:

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

例如：

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

从排列中获得的值用作自定义估计器的输入。

Parameters:

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)

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
treatment_name – str: 处理的名称
num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
transformation_list (list, optional) –
这是一个要执行的操作列表，用于获得结果，默认为 DEFAULT_TRANSFORMATION。默认的转换如下：

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

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

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

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

字符串参数

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

线性回归

K近邻

支持向量机

神经网络

随机森林

或者函数如：

Permute 这会对结果的行进行排列，消除治疗对结果的任何影响。

Noise 这会在结果中添加白噪声，减少与治疗的任何因果关系。

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

Examples:
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} )]

Parameters:: true_causal_effect – 一个用于获取模拟结果的真实因果效应的函数。它默认为 DEFAULT_TRUE_CAUSAL_EFFECT，这意味着在模拟数据中，处理和结果之间没有关系。

注意

真正的因果效应应该接受与处理相同形状的输入，并且输出应该与结果的形状匹配

Parameters:: required_variables – 用作y~f(W)输入的变量列表默认情况下，这是True，从而选择除处理和结果之外的所有变量

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。

如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

注意

这些输入被提供给函数以估计结果变量。每个内部估计函数的实例都使用相同的required_variables集合。

Parameters:

bucket_size_scale_factor – 对于连续数据，比例因子帮助我们缩放用于数据的桶的大小。默认比例因子是 DEFAULT_BUCKET_SCALE_FACTOR。
min_data_point_threshold (int, optional) – 估计器运行所需的最小数据点数。默认值为 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)[来源]#

基础类：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。

Parameters:

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

对于加法度量（OLS, MD），使用0。（默认值 = 无）

benchmark(data: DataFrame)[source]#

使用McGowan和Greevy Jr.的观察协变量E值对E值进行基准测试。这种方法会删除已测量的混杂因素并重新拟合估计器，测量置信区间的限制边界在E值尺度上的变化程度。这将假设的未测量混杂因素与每个已测量的混杂因素进行基准测试。

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

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

计算点估计和置信限的E值。使用观察到的协变量E值对E值进行基准测试。绘制E值和观察到的协变量E值。

Parameters:: plot – 绘制点估计和置信限的E值。（默认 = True）

get_evalue(coef_est, coef_se)[来源]#

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

Parameters:

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)[源代码]#

绘制轮廓图，显示治疗-混杂因素和混杂因素-结果风险比的组合，这些组合会影响点估计和置信限。X轴显示治疗-混杂因素风险比，Y轴显示混杂因素-结果风险比。

Parameters:

num_points_per_contour – 每个等高线计算和绘制的点数（默认 = 200）
plot_size – 图表的大小（默认 = (6.4,4.8)）
contour_colors – 点估计和置信限轮廓的颜色（默认 = [“blue”, “red”]）
benchmarking_color – 观察到的协变量E值的颜色。（默认 = “green”）
xy_limit – 图的最大x和y值。默认是2倍的E值。（默认 = 无）

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')[源代码]#

基础类：CausalRefuter

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

初始化用于图形反驳的数据

:param data:input 数据集 :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)[来源]#

refute_model(independence_constraints)[source]#

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

Parameters:: independence_constraints – 用于测试条件独立性的蕴含列表

:返回 : 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)[源代码]#

基础类：object

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

Parameters:

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

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

check_sensitivity(plot=True)[源代码]#

执行敏感性分析的函数。 :param plot: plot = True 生成点估计和未观察到的混杂因素变化的图。

plot = False 覆盖了设置

Returns:: LinearSensitivityAnalyzer 类的实例

compute_bias_adjusted(r2tu_w, r2yu_tw)[来源]#

计算偏差调整估计值、标准误差、t值、部分R2、置信区间

Parameters:

r2tu_w – 在控制观察到的协变量w后，从未观察到的混杂因素u对治疗t的回归中得到的部分r^2
r2yu_tw – 在控制观察到的协变量 w 和处理 t 后，从未观察到的混杂因素 u 对结果 y 进行回归的部分 r^2

Returns:

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

partial_r2_func(estimator_model=None, treatment=None)[来源]#

计算回归模型的部分R^2

Parameters:

estimator_model – 线性回归模型
treatment – 处理名称

Returns:

部分 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))[来源]#

绘制并总结敏感性边界作为等高线图，随着未观察到的混杂因素与处理和结果的部分R^2的变化而变化可以生成两种类型的图，基于调整后的估计值或调整后的t值 X轴：处理和未观察到的混杂因素的部分R^2 Y轴：结果和未观察到的混杂因素的部分R^2 我们还绘制了从观察到的协变量获得的未观察到的混杂因素的部分R^2的边界

Parameters:

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 – 轮廓线的颜色（默认 = 蓝色）字符串或数组。如果是数组，线条将按升序使用特定颜色绘制。
critical_contour_color – 阈值线的颜色（默认 = 红色）
label_fontsize – 用于标注等高线的字体大小（默认 = 9）
contour_linewidths – 等高线的线宽（默认 = 0.75）
contour_linestyles – 等高线的线型（默认 = “solid”）参见：https://matplotlib.org/3.5.0/gallery/lines_bars_and_markers/linestyles.html 获取更多示例
contours_label_color – 轮廓线标签的颜色（默认 = 黑色）
critical_label_color – 阈值线标签的颜色（默认 = 红色）
unadjusted_estimate_marker – 图中未调整估计的标记类型（默认 = ‘D’）参见: https://matplotlib.org/stable/api/markers_api.html
adjusted_estimate_marker – 图中偏差调整估计的标记类型（默认 = ‘^’）

Parm unadjusted_estimate_color:

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

Parm adjusted_estimate_color:

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

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

plot_estimate(r2tu_w, r2yu_tw)[source]#

计算用于绘制估计值的等高线、阈值线和边界。等高线（z轴）对应于不同r2tu_w（x）和r2yu_tw（y）值的调整估计值。 :param r2tu_w: 假设的混杂因素与治疗的部分R^2（x轴） :param r2yu_tw: 假设的混杂因素与结果的部分R^2（y轴）

Returns:

contour_values : 绘图的等高线值 critical_estimate : 阈值点 estimate_bounds : 未观察到的混杂因素的估计值（偏差调整估计）

plot_t(r2tu_w, r2yu_tw)[来源]#

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

Returns:

contour_values : 绘图的等高线值 critical_t : 阈值点 t_bounds : 未观察到的混杂因素的t值（偏差调整后的t值）

robustness_value_func(alpha=1.0)[来源]#

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

Parameters:: alpha – 置信区间（默认 = 1）
Returns:: 鲁棒性值

treatment_regression()[source]#

用于以治疗为结果进行回归的函数

Returns:: 新的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

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

Two important quantities used to estimate the bias are alpha and 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) 表示长Reisz表示器 α_s := (T - E[T | W] ) / (E(T - E[T | W]) ^ 2) 表示短Reisz表示器

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

Based on this work:: Chernozhukov, V., Cinelli, C., Newey, W., Sharma, A., & Syrgkanis, V. (2022). 长话短说：因果机器学习中的遗漏变量偏差 (No. w30302). 国家经济研究局.

Parameters:

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”中的估计器对象顺序一致

Parameters:

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]

Parameters:: plot – plot = True 生成一个图表，显示不同未观察到的混杂变量变化下估计的下置信界。 plot = False 覆盖此设置
Returns:: NonParametricSensitivityAnalyzer 类的实例

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

计算reisz函数的方差

Parameters:

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

Returns:

reisz函数的方差

get_phi_lower_upper(Cg, Calpha)[source]#

计算下界和上界影响函数（phi）

Parameters:

Cg – 衡量在结果回归中遗漏变量所产生的混杂强度的指标
Calpha – 衡量在治疗回归中遗漏变量产生的混杂强度的指标

:返回 : 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方法。对于所有其他方法（或当部分线性假设不能保证满足时），请使用非参数敏感性分析。

Based on this work:: Chernozhukov, V., Cinelli, C., Newey, W., Sharma, A., & Syrgkanis, V. (2022). 长话短说：因果机器学习中的遗漏变量偏差 (No. w30302). 国家经济研究局.

Parameters:

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”中的估计器对象顺序一致

Parameters:

observed_common_causes – 常见原因数据框
outcome – 结果数据框
treatment – 治疗数据框

calculate_robustness_value(alpha, is_partial_linear)[source]#

计算估计值对混杂因素的稳健性值的函数 :param alpha: 统计推断的置信区间

Returns:: 鲁棒性值

check_sensitivity(plot=True)[源代码]#

执行敏感性分析的函数。

Parameters:: plot – plot = True 生成一个图表，显示不同未观察到的混杂变量变化下估计的下置信界。 plot = False 覆盖此设置
Returns:: 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)[来源]#

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

Returns delta_r2_y_wj:: 在回归方程中包含基准协变量时，观察到解释力度的增加与结果相关
Returns delta_r2t_wj:: 在回归方程中包含基准协变量时，观察到处理对解释力的附加增益

get_confidence_levels(r2yu_tw, r2tu_w, significance_level, is_partial_linear)[来源]#

返回效应估计的下限和上限，给定未观察到的混杂因素的不同解释力。它使用以下定义。

Parameters:

r2yu_tw – 由混杂因素解释的结果中剩余方差的比例
r2tu_w – 由混杂因素解释的治疗中剩余方差的比例
significance_level – 统计推断的置信区间（默认 = 0.05）
is_partial_linear – 数据生成过程是否被假设为部分线性

Returns lower_confidence_bound:

估计的置信下限

Returns upper_confidence_bound:

估计的置信上限

Returns bias:

混杂场景中的遗漏变量偏差

get_phi_lower_upper(Cg, Calpha)[source]#

计算下界和上界影响函数（phi）

Parameters:

Cg – 衡量在结果回归中遗漏变量所产生的混杂强度的指标
Calpha – 衡量在治疗回归中遗漏变量产生的混杂强度的指标

:返回 : phi的下界, phi的上界

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

从回归函数中计算皮尔逊非参数部分R^2。

Parameters:

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

Returns:

部分 R^2 值

is_benchmarking_needed()[source]#

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

Parameters:

r2yu_tw – 由混杂因素解释的结果中剩余方差的比例
r2tu_w – 由混杂因素解释的治疗中剩余方差的比例
significance_level – 边界所需的显著性水平
is_partial_linear – 我们是否假设数据生成过程是部分线性的

Returns:

存储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]#

Parameters:

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

Parm 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

通过用随机生成的安慰剂变量替换治疗来反驳一个估计。

Parameters:

placebo_type (str, optional) – 默认情况下，为处理生成随机值。如果 placebo_type 是 "permute"，则原始处理值按行进行排列。
num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想要重复相同的行为，我们会在伪随机生成器中推送相同的种子。
n_jobs (int, optional) – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose (int, optional) – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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]#

通过用随机生成的安慰剂变量替换治疗来反驳一个估计。

Parameters:

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时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过10，则报告所有迭代。默认值为0。

dowhy.causal_refuters.random_common_cause 模块#

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

基础类：CausalRefuter

通过引入一个随机生成的混淆变量（可能是未观察到的）来反驳一个估计。

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们希望重复相同的行为，我们在伪随机生成器中推送相同的种子。
n_jobs (int, optional) – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose (int, optional) – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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]#

通过引入一个随机生成的混淆变量（可能是未观察到的）来反驳一个估计。

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state – 如果我们希望重复相同的随机行为，则需要添加的种子值。如果我们想要重复相同的行为，我们会在伪随机生成器中推送相同的种子。
n_jobs – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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]#

Executes a list of refuters using the default parameters: 仅支持返回CausalRefutation或CausalRefutation列表的反驳者

Parameters:

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

**kwargskwargs:

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

dowhy.causal_refuters.reisz 模块#

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

基础类：object

用于平均处理效果的Plugin 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

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

fit(X)[source]#

predict(X_test)[来源]#

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表示器（alpha_s）估计器

Parameters:

cv – 在数据集进行K折后获得的训练和测试数据索引
X – 治疗+混杂因素
max_degree – 用于近似 alpha_s 的多项式函数的次数
param_grid_dict – 用于调整ReiszRepresenter估计器的参数的Python字典

Returns:

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) 的最佳估计器

Parameters:

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

Returns:

Reisz回归函数的估计器

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

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

Returns:: 量化模型预测的浮点数

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

模块内容#

class dowhy.causal_refuters.AddUnobservedCommonCause(*args, **kwargs)[源代码]#

基础类：CausalRefuter

为反驳添加一个未观察到的混淆因素。

AddUnobservedCommonCause class supports three methods:

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

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

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

Parameters:

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表示器的方差比例；具体来说，是(1-r)，其中r是基于已观察到的混杂变量的reisz表示器的方差比，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）。（仅适用于基于partial-r2的模拟方法）
null_hypothesis_effect – 零假设下的假定效应。（仅与linear-partial-R2相关，其余情况忽略）
plot_estimate – 在执行敏感性分析时生成估计的等高线图。（默认 = True）。（仅适用于基于partial-r2的模拟方法）
num_splits – 交叉验证的分割次数。（默认值 = 5）。（仅适用于非参数部分R2模拟方法）

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

refute_estimate(show_progress_bar=False)[源代码]#

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

基础类：CausalRefuter

通过在包含混杂因素测量误差的数据的随机样本上运行估计来反驳估计。这使我们能够找到估计器发现治疗对结果影响的能力。

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

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
sample_size (int, optional) – 每个引导样本的大小，默认情况下是原始数据的大小
required_variables (int, list, bool, optional) – 用作y~f(W)输入的变量列表默认情况下为True，这将选择所有变量，排除处理和结果

一个整数参数指的是将使用多少个变量来估计结果的值
一个列表明确指出了哪些变量将用于估计结果此外，它还提供了明确选择或取消选择在结果估计中存在的协变量的能力。这是通过添加或明确从列表中移除变量来实现的，如下所示：

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。
如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

Parameters:

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

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

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

Parameters:

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

DEFAULT_SUBSET_FRACTION = 0.8#

refute_estimate(show_progress_bar: bool = False)[源代码]#

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() 方法中指定的附加参数。

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
transformation_list (list, optional) –
这是一个要执行的操作列表，用于获得结果，默认为 DEFAULT_TRANSFORMATION。默认的转换如下：

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

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

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

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

字符串参数

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

线性回归

K近邻

支持向量机

神经网络

随机森林

或者函数如：

Permute 这会对结果的行进行排列，消除治疗对结果的任何影响。

Noise 这会在结果中添加白噪声，减少与治疗的任何因果关系。

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

Examples:
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} )]

Parameters:: true_causal_effect – 一个用于获取模拟结果的真实因果效应的函数。它默认为 DEFAULT_TRUE_CAUSAL_EFFECT，这意味着在模拟数据中，处理和结果之间没有关系。

注意

真正的因果效应应该接受与处理相同形状的输入，并且输出应该与结果的形状匹配

Parameters:: required_variables – 用作y~f(W)输入的变量列表默认情况下，这是True，从而选择除处理和结果之外的所有变量

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。

如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

注意

这些输入被提供给函数以估计结果变量。每个内部估计函数的实例都使用相同的required_variables集合。

Parameters:

bucket_size_scale_factor – 对于连续数据，比例因子帮助我们缩放用于数据的桶的大小。默认比例因子是 DEFAULT_BUCKET_SCALE_FACTOR。
min_data_point_threshold (int, optional) – 估计器运行所需的最小数据点数。默认值为 MIN_DATA_POINT_THRESHOLD。如果某个类别的数据点太少，我们将使用 DEFAULT_TRANSFORMATION 来生成虚拟结果。

refute_estimate(show_progress_bar: bool = False)[源代码]#

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

基础类：CausalRefuter

通过用随机生成的安慰剂变量替换治疗来反驳一个估计。

Parameters:

placebo_type (str, optional) – 默认情况下，为处理生成随机值。如果 placebo_type 是 "permute"，则原始处理值按行进行排列。
num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们想要重复相同的行为，我们会在伪随机生成器中推送相同的种子。
n_jobs (int, optional) – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose (int, optional) – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过10，则报告所有迭代。默认值为0。

refute_estimate(show_progress_bar=False)[source]#

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

基础类：CausalRefuter

通过引入一个随机生成的混淆变量（可能是未观察到的）来反驳一个估计。

Parameters:

num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state (int, RandomState, optional) – 如果我们希望重复相同的随机行为，则添加的种子值。如果我们希望重复相同的行为，我们在伪随机生成器中推送相同的种子。
n_jobs (int, optional) – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose (int, optional) – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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]#

通过在包含混杂因素测量误差的数据的随机样本上运行估计来反驳估计。这使我们能够找到估计器发现治疗对结果影响的能力。

Parameters:

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时。

Parameters:

n_jobs – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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]#

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

Parameters:

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时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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)

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
treatment_name – str: 处理的名称
num_simulations (int, optional) – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
transformation_list (list, optional) –
这是一个要执行的操作列表，用于获得结果，默认为 DEFAULT_TRANSFORMATION。默认的转换如下：

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

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

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

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

字符串参数

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

线性回归

K近邻

支持向量机

神经网络

随机森林

或者函数如：

Permute 这会对结果的行进行排列，消除治疗对结果的任何影响。

Noise 这会在结果中添加白噪声，减少与治疗的任何因果关系。

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

Examples:
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} )]

Parameters:: true_causal_effect – 一个用于获取模拟结果的真实因果效应的函数。它默认为 DEFAULT_TRUE_CAUSAL_EFFECT，这意味着在模拟数据中，处理和结果之间没有关系。

注意

真正的因果效应应该接受与处理相同形状的输入，并且输出应该与结果的形状匹配

Parameters:: required_variables – 用作y~f(W)输入的变量列表默认情况下，这是True，从而选择除处理和结果之外的所有变量

注意

如果我们想要W0和W1，我们需要传递required_variables = [W0,W1]。

如果我们需要排除 W0 和 W1 之外的所有变量，我们需要传递 required_variables = [-W0,-W1]。

如果值为 True，我们希望包含所有变量来估计结果的值。

警告

一个 False 值是 INVALID 并且会导致一个 error。

注意

这些输入被提供给函数以估计结果变量。每个内部估计函数的实例都使用相同的required_variables集合。

Parameters:

bucket_size_scale_factor – 对于连续数据，比例因子帮助我们缩放用于数据的桶的大小。默认比例因子是 DEFAULT_BUCKET_SCALE_FACTOR。
min_data_point_threshold (int, optional) – 估计器运行所需的最小数据点数。默认值为 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]#

Executes a list of refuters using the default parameters: 仅支持返回CausalRefutation或CausalRefutation列表的反驳者

Parameters:

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

**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]#

通过用随机生成的安慰剂变量替换治疗来反驳一个估计。

Parameters:

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时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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[source]#

通过引入一个随机生成的混淆变量（可能是未观察到的）来反驳一个估计。

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
num_simulations – 要运行的模拟次数，默认为 CausalRefuter.DEFAULT_NUM_SIMULATIONS
random_state – 如果我们希望重复相同的随机行为，则需要添加的种子值。如果我们想要重复相同的行为，我们会在伪随机生成器中推送相同的种子。
n_jobs – 最大并发运行的作业数。如果为-1，则使用所有CPU。如果为1，则不使用任何并行计算代码（这是默认值）。
verbose – 详细程度：如果非零，则打印进度消息。超过50时，输出将发送到stdout。消息的频率随着详细程度的增加而增加。如果超过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[source]#

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[source]#

Parameters:

data – pd.DataFrame: 用于运行反驳的数据
target_estimand – IdentifiedEstimand: 用于运行反驳的已识别估计量
estimate – CausalEstimate: 用于运行反驳的估计
treatment_name – str: 处理的名称
outcome_name – str: 结果的名称
kappa_t – float, numpy.ndarray: 混杂因素对治疗影响的强度。当混杂因素对治疗的影响是线性时，它是回归系数。当混杂因素对治疗的影响是二元翻转时，它是未观察到的混杂因素可以反转治疗值的概率。
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”。

Returns:

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 模块#

模块内容#