econml.grf.CausalIVForest

class econml.grf.CausalIVForest(n_estimators=100, *, criterion='mse', max_depth=None, min_samples_split=10, min_samples_leaf=5, min_weight_fraction_leaf=0.0, min_var_fraction_leaf=None, min_var_leaf_on_val=False, max_features='auto', min_impurity_decrease=0.0, max_samples=0.45, min_balancedness_tol=0.45, honest=True, inference=True, fit_intercept=True, subforest_size=4, n_jobs=- 1, random_state=None, verbose=0, warm_start=False)[source]

基类： econml.grf._base_grf.BaseGRF

一个因果 IV 森林 [cfiv1]。它拟合一个解决局部矩方程问题的森林。

树中的每个节点包含参数 theta(x) 的局部估计，对应于落入该叶节点的 X 的每个区域。

参数

n_estimators (int, 默认值 100) – 树的数量
criterion ({"mse", "het"}, 默认值 “mse”) – 衡量分割质量的函数。支持的标准有线性矩估计树中的“mse”表示均方误差，“het”表示异质性分数。
- “mse”标准寻找大致最小化分数的分割
```
sum_{child} E[(Y - <theta(child), E[T|Z]> - beta(child))^2 | X=child] weight(child)
```
  但我们注意到，局部估计仍然是通过求解落入该节点的样本的局部矩方程来估计的，而不是通过最小化此损失来实现的。在内部，对于超过两个处理变量或一个处理变量且 fit_intercept=True 的情况，出于计算目的，此标准由计算上更简单的变体近似替代。特别是，它被替换为
```
sum_{child} weight(child) * rho(child).T @ E[(T;1) @ (Z;1).T | X in child] @ rho(child)
```
  其中
```
rho(child) := E[(T;1) @ (Z;1).T | X in parent]^{-1}
                  * E[(Y - <theta(x), T> - beta(x)) (Z;1) | X in child]
```
  这可以被视为一种诱导异质性的分数，但对子节点 Jacobi 矩阵 E[(T;1) @ (Z;1).T | X in child] 的最小特征值较大的分数赋予更多权重，这会使得估计值的方差更小，参数识别更强。
- "het" 标准寻找最大化纯参数异质性分数的分割
```
sum_{child} weight(child) * rho(child)[:n_T].T @ rho(child)[:n_T]
```
  这可以被视为理想异质性分数的一种近似
```
weight(left) * weight(right) || theta(left) - theta(right)||_2^2 / weight(parent)^2
```
  如 [cfiv1] 中所述
max_depth (int, 默认值 None) – 树的最大深度。如果为 None，则节点将一直扩展，直到所有叶节点都是纯的，或直到所有叶节点包含的样本少于 min_samples_split。
min_samples_split (int 或 float, 默认值 10) – 分割内部节点所需的最小样本数
- 如果是 int，则 min_samples_split 作为最小数量。
- 如果是 float，则 min_samples_split 是一个分数，每个分割所需的最小样本数是 ceil(min_samples_split * n_samples)。
min_samples_leaf (int 或 float, 默认值 5) – 叶节点所需的最小样本数。只有当分割点在左右分支中至少留下 min_samples_leaf 个训练样本时，才会考虑任何深度的分割点。这可能会使模型更加平滑，尤其是在回归中。
- 如果是 int，则 min_samples_leaf 作为最小数量。
- 如果是 float，则 min_samples_leaf 是一个分数，每个节点所需的最小样本数是 ceil(min_samples_leaf * n_samples)。
min_weight_fraction_leaf (float, 默认值 0.0) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。如果未提供 sample_weight，则样本权重相等。
min_var_fraction_leaf (None 或 (0, 1] 之间的 float, 默认值 None) – 对处理变量与工具变量协方差变化的某个代理的约束，要求每个叶节点中包含该协方差变化占整个样本处理变量和工具变量总协方差-方差的百分比。这避免了在处理变量方差较小、或工具变量方差较小、或工具变量对处理变量的局部影响较弱从而导致局部参数识别不良且方差较高的情况下进行分割。方差的代理因标准而异，主要出于计算效率的原因。
- 如果 criterion='het'，则此约束转化为
```
for all i in {1, ..., T.shape[1]}:
    E[T[i] Z[i] | X in leaf] > `min_var_fraction_leaf` * E[T[i] Z[i]]
```
  当 T 是残差处理变量，Z 是残差工具变量（即中心化后），这相当于要求
```
for all i in {1, ..., T.shape[1]}:
    Cov(T[i], Z[i] | X in leaf) > `min_var_fraction_leaf` * Cov(T[i], Z[i])
```
- 如果 criterion='mse'，由于此标准对每个候选分割都存储了更多关于叶节点的信息，因此此约束对每个处理变量不同坐标的成对相关性施加了进一步的约束。例如，当工具变量和处理变量都经过残差化（中心化）后，此约束转化为
```
for all i neq j:
    E[T[i]Z[i]] E[T[j]Z[j]] - E[T[i] Z[j]]
    sqrt(Cov(T[i], Z[i] |X in leaf) * Cov(T[j], Z[j]|X in leaf)
            * (1 - rho(T[i], Z[j]|X in leaf) * rho(T[j], Z[i]|X in leaf)))
      > `min_var_fraction_leaf` * sqrt(Cov(T[i], Z[i]) * Cov(T[j], Z[j])
                                        * (1 - rho(T[i], Z[j]) * rho(T[j], Z[i])))
```
  其中 rho(X, Y) 是两个随机变量 X, Y 的 Pearson 相关系数。因此，此约束还强制要求在一个叶节点内，没有两对处理变量和工具变量是高度共线的。此额外约束主要在输入处理变量超过两个的情况下发挥作用，并且还避免了由于处理变量的局部共线性导致参数估计方差较大的叶节点。
min_var_leaf_on_val (bool, 默认值 False) – 是否也应在诚实分割的验证集上强制执行 min_var_fraction_leaf 约束。如果 min_var_leaf=None，则此标志无效。设置此选项为 True 应谨慎，因为它部分违反了诚实结构，因为除 X 变量以外的部分变量（例如，用于线性模型 Jacobi 矩阵 J 的变量）被用来指导树的分割结构。然而，这是一种良性依赖，因为它仅使用处理变量 T 及其局部相关结构来决定分割是否可行。
max_features (int, float, {“auto”, “sqrt”, “log2”}, 或 None, 默认值 None) – 寻找最佳分割时要考虑的特征数量
- 如果是 int，则在每次分割时考虑 max_features 个特征。
- 如果是 float，则 max_features 是一个分数，每次分割时考虑 int(max_features * n_features) 个特征。
- 如果是 “auto”，则 max_features=n_features。
- 如果是 “sqrt”，则 max_features=sqrt(n_features)。
- 如果是 “log2”，则 max_features=log2(n_features)。
- 如果是 None，则 max_features=n_features。
注意：即使需要检查的特征数量实际上超过了 max_features，寻找分割的过程也不会停止，直到找到至少一个有效的节点样本划分。
min_impurity_decrease (float, 默认值 0.0) – 如果此分割引起的杂质减少量大于或等于此值，则会分割节点。加权杂质减少公式如下：
```
N_t / N * (impurity - N_t_R / N_t * right_impurity
                    - N_t_L / N_t * left_impurity)
```
其中 N 是样本总数，N_t 是当前节点的样本数，N_t_L 是左子节点的样本数，N_t_R 是右子节点的样本数。如果传递了 sample_weight，则 N、N_t、N_t_R 和 N_t_L 都指加权和。
max_samples (int 或 (0, 1] 之间的 float, 默认值 .45,) – 用于训练每棵树的子样本数量
- 如果是 int，则每棵树使用 max_samples 个样本进行训练，从所有样本中无放回抽样。
- 如果是 float，则每棵树使用 ceil(max_samples * n_samples) 个样本进行训练，从所有样本中无放回抽样。
如果 inference=True，则 max_samples 必须是小于 n_samples//2 的整数，或者是小于或等于 0.5 的 float。
min_balancedness_tol ([0, 0.5] 之间的 float, 默认值 0.45) – 可容忍的分割不平衡程度。这强制要求每次分割后，两侧至少保留 (.5 - min_balancedness_tol) 比例的样本；或者在 sample_weight 不为 None 时，至少保留总样本权重的该比例。默认值确保父节点权重的至少 5% 落入分割的每一侧。设置为 0.0 表示不要求平衡，设置为 0.5 表示完全平衡分割。为了使形式化推断理论有效，此值必须是任何远离零的正常数。
honest (bool, 默认值 True) – 每棵树是否应以“诚实”的方式训练，即训练集被分成两个大小相等的子集：训练集和验证集。训练集中的所有样本用于创建分割结构，验证集中的所有样本用于计算树中每个节点的值。
inference (bool, 默认值 True) – 是否启用推断（即置信区间构建和估计值的不确定性量化）。如果 inference=True，则估计器使用 little-bags bootstrap 方法计算参数向量的协方差，并应用客观贝叶斯去偏校正，以确保方差量为正。
fit_intercept (bool, 默认值 True) – 是否应该拟合截距干扰参数 beta(x)。如果 fit_intercept=False，则在此文档字符串中的所有计算中，处理变量后面不会附加 (;1)。如果 fit_intercept=True，则常量处理变量 (;1) 会附加到每个处理向量后面，并且此常量处理变量前面的系数即为截距 beta(x)。beta(x) 被视为干扰项，不通过 predict(X)、predict_and_var(X) 或 predict_var(X) 方法返回。使用 predict_full(X) 方法也可以恢复截距项。
subforest_size (int, 默认值 4,) – 用于 little-bags bootstrap 计算的每个子森林中的树的数量。参数 n_estimators 必须能被 subforest_size 整除。通常应为一个小的常数。
n_jobs (int 或 None, 默认值 -1) – 用于并行计算的并行作业数量；遵循 joblib 语义。n_jobs=-1 表示使用所有可用的 CPU 核心。n_jobs=None 表示不进行并行计算。
random_state (int, RandomState 实例, 或 None, 默认值 None) – 控制估计器的随机性。特征在每次分割时总是随机排列的。当 max_features < n_features 时，算法在每次分割时随机选择 max_features 个特征，然后再在其中找到最佳分割。但即使 max_features=n_features，不同运行之间的最佳分割点也可能有所不同。当几个分割点的标准改进相同时，需要随机选择一个分割点时，就会出现这种情况。为了在拟合期间获得确定性行为，random_state 必须固定为一个整数。
verbose (int, 默认值 0) – 控制拟合和预测时的详细程度。
warm_start (bool, 默认值 False) – 设置为 True 时，重用上次调用 fit 的解决方案并向集成模型添加更多估计器，否则，直接拟合一个全新的森林。如果为 True，则无法使用 oob_predict 方法进行袋外预测。

feature_importances_

基于特征创建的参数异质性程度来衡量特征重要性。值越高，特征越重要。特征的重要性计算为该特征创建的（归一化）总异质性。选择该特征进行分割的每次分割都会增加

parent_weight * (left_weight * right_weight)
    * mean((value_left[k] - value_right[k])**2) / parent_weight**2

到该特征的重要性中。每个这样的量也按分割的深度进行加权。默认情况下，深度小于 max_depth=4 的分割不用于此计算，并且深度为 depth 的每个分割会根据 1 / (1 + `depth`)**2.0 重新加权。有关允许更改这些默认值的方法，请参阅 feature_importances 方法。

类型: 形状为 (n_features,) 的 ndarray

estimators_

拟合的树。

类型: 类型为 GRFTree 的对象列表

参考文献

cfiv1(1,2): Athey, Susan, Julie Tibshirani, and Stefan Wager. “Generalized random forests.” The Annals of Statistics 47.2 (2019): 1148-1178 https://arxiv.org/pdf/1610.01271.pdf

__init__(n_estimators=100, *, criterion='mse', max_depth=None, min_samples_split=10, min_samples_leaf=5, min_weight_fraction_leaf=0.0, min_var_fraction_leaf=None, min_var_leaf_on_val=False, max_features='auto', min_impurity_decrease=0.0, max_samples=0.45, min_balancedness_tol=0.45, honest=True, inference=True, fit_intercept=True, subforest_size=4, n_jobs=- 1, random_state=None, verbose=0, warm_start=False)[source]

方法

`__init__`([n_estimators, criterion, ...])
`apply`(X)	将森林中的树应用于 X，返回叶节点索引。
`decision_path`(X)	返回森林中的决策路径。
`feature_importances`([max_depth, ...])	基于特征创建的参数异质性程度来衡量特征重要性。值越高，特征越重要。特征的重要性计算为该特征创建的（归一化）总异质性。对于每棵树和每次选择该特征进行分割的情况，都会增加：。
`fit`(X, T, y, *, Z[, sample_weight])	从训练集 (X, T, y, Z) 构建 IV 森林。
`get_params`([deep])	获取此估计器的参数。
`get_subsample_inds`()	使用相同的伪随机性，重新生成与拟合时相同的样本索引。
`oob_predict`(Xtrain)	返回每个训练数据点相关的输出预测，仅包含未用于该数据点的树。
`predict`(X[, interval, alpha])	返回 X 中每个 x 的相关拟合局部参数的前缀，即 theta(x)[1..n_relevant_outputs]。
`predict_alpha_and_jac`(X[, slice, parallel])	使用森林作为核权重，返回条件 Jacobian E[J \| X=x] 的值和条件 alpha E[A \| X=x] 的值，即。
`predict_and_var`(X)	返回 X 中每个 x 的相关拟合局部参数的前缀，即 theta(x)[1..n_relevant_outputs] 及其协方差矩阵。
`predict_full`(X[, interval, alpha])	返回 X 中每个 x 的拟合局部参数，即 theta(x)。
`predict_interval`(X[, alpha])	返回 X 中每个 x 的相关拟合局部参数的置信区间，即 theta(x)[1..n_relevant_outputs]。
`predict_moment_and_var`(X, parameter[, ...])	返回每个样本处的条件期望矩向量的值，以及每个样本给定参数估计值时的矩向量值。
`predict_projection`(X, projector)	返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积，即：。
`predict_projection_and_var`(X, projector)	返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积，即：。
`predict_projection_var`(X, projector)	返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积的方差，即：。
`predict_tree_average`(X)	返回每个 X 的相关拟合局部参数的前缀，即 theta(X)[1..n_relevant_outputs]。此方法仅返回每棵树估计的参数的平均值。predict 方法比 pred_tree_average 更稳定，因为它执行的是更稳定的跨树平均。
`predict_tree_average_full`(X)	返回每个 X 的拟合局部参数，即 theta(X)。此方法仅返回每棵树估计的参数的平均值。predict_full 方法比 pred_tree_average_full 更稳定，因为它执行的是更稳定的跨树平均。
`predict_var`(X)	返回 X 中每个 x 的相关拟合局部参数前缀的协方差矩阵。
`prediction_stderr`(X)	返回 X 中每个 x 的相关拟合局部参数前缀的每个坐标的标准差。
`set_params`(**params)	设置此估计器的参数。

属性

feature_importances_

apply(X)

将森林中的树应用于 X，返回叶节点索引。

参数: X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
返回: X_leaves – 对于 X 中的每个数据点 x 和森林中的每棵树，返回 x 最终所在的叶节点索引。
返回类型: 形状为 (n_samples, n_estimators) 的 ndarray

decision_path(X)

返回森林中的决策路径。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。

返回

indicator (形状为 (n_samples, n_nodes) 的稀疏矩阵) – 返回一个节点指示矩阵，其中非零元素表示样本通过这些节点。该矩阵采用 CSR 格式。
n_nodes_ptr (形状为 (n_estimators + 1,) 的 ndarray) – indicator[n_nodes_ptr[i]:n_nodes_ptr[i+1]] 中的列给出了第 i 个估计器的指示值。

feature_importances(max_depth=4, depth_decay_exponent=2.0)

基于特征创建的参数异质性程度来衡量特征重要性。值越高，特征越重要。特征的重要性计算为该特征创建的（归一化）总异质性。对于每棵树和每次选择该特征进行分割的情况，都会增加

parent_weight * (left_weight * right_weight)
    * mean((value_left[k] - value_right[k])**2) / parent_weight**2

到该特征的重要性中。每个这样的量也按分割的深度进行加权。这些重要性在树级别进行归一化，然后跨树取平均。

参数

max_depth (int, 默认值 4) – 深度大于 max_depth 的分割不用于此计算
depth_decay_exponent (double, 默认值 2.0) – 每个分割对总分的贡献根据 1 / (1 + depth)**2.0 重新加权。

返回

feature_importances_ – 每个特征诱导参数异质性的归一化总重要性

返回类型

形状为 (n_features,) 的 ndarray

fit(X, T, y, *, Z, sample_weight=None)[source]

从训练集 (X, T, y, Z) 构建 IV 森林。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 训练输入样本。在内部，其 dtype 将被转换为 dtype=np.float64。
T (形状为 (n_samples, n_treatments) 的 array_like) – 每个样本的处理向量
y (形状为 (n_samples,) 或 (n_samples, n_outcomes) 的 array_like) – 每个样本的结果值。
Z (形状为 (n_samples, n_treatments) 的 array_like) – 工具向量。此方法需要等量的工具变量和处理变量，即恰好识别的 IV 回归。为了降低方差，可以在第一阶段估计中将工具变量投影到处理向量上，即 Z -> E[T | Z]，以此使用最优工具变量。
sample_weight (形状为 (n_samples,) 的 array_like, 默认值 None) – 样本权重。如果为 None，则样本权重相等。在每个节点中寻找分割点时，会忽略那些会创建净权重为零或负数的子节点的分割点。

返回

self

返回类型

object

get_params(deep=True)

获取此估计器的参数。

参数: deep (bool, 默认值 True) – 如果为 True，将返回此估计器及其包含的作为估计器的子对象的参数。
返回: params – 参数名称及其对应值。
返回类型: dict

get_subsample_inds(): 使用相同的伪随机性，重新生成与拟合时相同的样本索引。

使用相同的伪随机性，重新生成与拟合时相同的样本索引。

返回每个训练数据点的相关输出预测，仅包含未用于该数据点的树。如果估计器使用 warm_start=True 进行训练，则此方法不可用。

参数: Xtrain ((n_training_samples, n_features) matrix) – 必须是与拟合时传递给森林的 X 矩阵完全相同的矩阵。
返回: oob_preds – 每个训练点的相关输出参数的袋外预测
返回类型: 形状为 (n_training_samples, n_relevant_outputs) 的矩阵

predict(X, interval=False, alpha=0.05)

返回 X 中每个 x 的相关拟合局部参数的前缀，即 theta(x)[1..n_relevant_outputs]。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
interval (bool, 默认值 False) – 是否也返回置信区间
alpha ((0, 1) 之间的 float, 默认值 0.05) – 置信区间的置信水平。返回一个对称的 (alpha/2, 1-alpha/2) 置信区间。

返回

theta(X)[1, .., n_relevant_outputs] (形状为 (n_samples, n_relevant_outputs) 的 array_like) – X 的每一行的估计相关参数
lb(x), ub(x) (形状为 (n_samples, n_relevant_outputs) 的 array_like) – 每个参数置信区间的下限和上限。如果 interval=False 则忽略返回值。

predict_alpha_and_jac(X, slice=None, parallel=True)

使用森林作为核权重，返回条件 Jacobian E[J | X=x] 的值和条件 alpha E[A | X=x] 的值，即。

alpha(x) = (1/n_trees) sum_{trees} (1/ |leaf(x)|) sum_{val sample i in leaf(x)} w[i] A[i]
jac(x) = (1/n_trees) sum_{trees} (1/ |leaf(x)|) sum_{val sample i in leaf(x)} w[i] J[i]

其中 w[i] 是样本权重（如果 sample_weight 为 None 则为 1.0）。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
slice (int 列表或 None, 默认值 None) – 如果不为 None，则仅使用索引在 slice 中的树来计算均值和方差。
parallel (bool , 默认值 True) – 是否应使用并行计算进行平均。并行计算会增加一些开销，但在树数量多时会更快。

返回

alpha (形状为 (n_samples, n_outputs) 的 array_like) – X 中每个样本 x 的估计条件 A, alpha(x)
jac (形状为 (n_samples, n_outputs, n_outputs) 的 array_like) – X 中每个样本 x 的估计条件 J, jac(x)

predict_and_var(X)

返回 X 中每个 x 的相关拟合局部参数的前缀，即 theta(x)[1..n_relevant_outputs] 及其协方差矩阵。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。

返回

theta(x)[1, .., n_relevant_outputs] (形状为 (n_samples, n_relevant_outputs) 的 array_like) – X 的每一行的估计相关参数
var(theta(x)) (形状为 (n_samples, n_relevant_outputs, n_relevant_outputs) 的 array_like) – theta(x)[1, .., n_relevant_outputs] 的协方差

predict_full(X, interval=False, alpha=0.05)

返回 X 中每个 x 的拟合局部参数，即 theta(x)。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
interval (bool, 默认值 False) – 是否也返回置信区间
alpha ((0, 1) 之间的 float, 默认值 0.05) – 置信区间的置信水平。返回一个对称的 (alpha/2, 1-alpha/2) 置信区间。

返回

theta(x) (形状为 (n_samples, n_outputs) 的 array_like) – X 的每一行 x 的估计相关参数
lb(x), ub(x) (形状为 (n_samples, n_outputs) 的 array_like) – 每个参数置信区间的下限和上限。如果 interval=False 则忽略返回值。

predict_interval(X, alpha=0.05)

返回 X 中每个 x 的相关拟合局部参数的置信区间，即 theta(x)[1..n_relevant_outputs]。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
alpha ((0, 1) 之间的 float, 默认值 0.05) – 置信区间的置信水平。返回一个对称的 (alpha/2, 1-alpha/2) 置信区间。

返回

lb(x), ub(x) – 每个参数置信区间的下限和上限。如果 interval=False 则忽略返回值。

返回类型

形状为 (n_samples, n_relevant_outputs) 的 array_like

predict_moment_and_var(X, parameter, slice=None, parallel=True)

返回每个样本处的条件期望矩向量的值，以及每个样本给定参数估计值时的矩向量值

M(x; theta(x)) := E[J | X=x] theta(x) - E[A | X=x]

其中条件期望基于森林权重估计，即

M_tree(x; theta(x)) := (1/ |leaf(x)|) sum_{val sample i in leaf(x)} w[i] (J[i] theta(x) - A[i])
M(x; theta(x) = (1/n_trees) sum_{trees} M_tree(x; theta(x))

其中 w[i] 是样本权重（如果 sample_weight 为 None 则为 1.0），以及局部矩向量在树之间的方差

Var(M_tree(x; theta(x))) = (1/n_trees) sum_{trees} M_tree(x; theta(x)) @ M_tree(x; theta(x)).T

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
parameter (形状为 (n_samples, n_outputs) 的 array_like) – X 中每个样本 x 的参数 theta(x) 估计值
slice (int 列表或 None, 默认值 None) – 如果不为 None，则仅使用索引在 slice 中的树来计算均值和方差。
parallel (bool , 默认值 True) – 是否应使用并行计算进行平均。并行计算会增加一些开销，但在树数量多时会更快。

返回

moment (形状为 (n_samples, n_outputs) 的 array_like) – X 中每个样本 x 的估计条件矩 M(x; theta(x))
moment_var (形状为 (n_samples, n_outputs) 的 array_like) – 每个样本 x 的条件矩 Var(M_tree(x; theta(x))) 在树之间的方差

predict_projection(X, projector)

返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积，即

mu(x) := <theta(x)[1..n_relevant_outputs], projector(x)>

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
projector (形状为 (n_samples, n_relevant_outputs) 的 array_like) – X 中每个样本 x 的投影向量

返回

mu(x) – X 的每一行 x 的相关参数与投影向量的估计内积

返回类型

形状为 (n_samples, 1) 的 array_like

predict_projection_and_var(X, projector)

返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积，即

mu(x) := <theta(x)[1..n_relevant_outputs], projector(x)>

以及 mu(x) 的方差。

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
projector (形状为 (n_samples, n_relevant_outputs) 的 array_like) – X 中每个样本 x 的投影向量

返回

mu(x) (形状为 (n_samples, 1) 的 array_like) – X 的每一行 x 的相关参数与投影向量的估计内积
var(mu(x)) (形状为 (n_samples, 1) 的 array_like) – 估计内积的方差

predict_projection_var(X, projector)

返回 X 中每个 x 的相关拟合局部参数的前缀（即 theta(x)[1..n_relevant_outputs]）与投影向量 projector(x) 的内积的方差，即

Var(mu(x)) for mu(x) := <theta(x)[1..n_relevant_outputs], projector(x)>

参数

X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
projector (形状为 (n_samples, n_relevant_outputs) 的 array_like) – X 中每个样本 x 的投影向量

返回

var(mu(x)) – 估计内积的方差

返回类型

形状为 (n_samples, 1) 的 array_like

predict_tree_average(X)

返回每个 X 的相关拟合局部参数的前缀，即 theta(X)[1..n_relevant_outputs]。此方法仅返回每棵树估计的参数的平均值。predict 方法比 pred_tree_average 更稳定，因为它执行的是更稳定的跨树平均。

参数: X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
返回: theta(X)[1, .., n_relevant_outputs] – X 的每一行的估计相关参数
返回类型: 形状为 (n_samples, n_relevant_outputs) 的 array_like

predict_tree_average_full(X)

返回每个 X 的拟合局部参数，即 theta(X)。此方法仅返回每棵树估计的参数的平均值。predict_full 方法比 pred_tree_average_full 更稳定，因为它执行的是更稳定的跨树平均。

参数: X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
返回: theta(X) – X 的每一行的估计相关参数
返回类型: 形状为 (n_samples, n_outputs) 的 array_like

predict_var(X)

返回 X 中每个 x 的相关拟合局部参数前缀的协方差矩阵。

参数: X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
返回: var(theta(x)) – theta(x)[1, .., n_relevant_outputs] 的协方差
返回类型: 形状为 (n_samples, n_relevant_outputs, n_relevant_outputs) 的 array_like

prediction_stderr(X)

返回 X 中每个 x 的相关拟合局部参数前缀的每个坐标的标准差。

参数: X (形状为 (n_samples, n_features) 的 array_like) – 输入样本。在内部，它将被转换为 dtype=np.float64。
返回: std(theta(x)) – 对于 i ∈ {1, .., n_relevant_outputs}，每个 theta(x)[i] 的标准差
返回类型: 形状为 (n_samples, n_relevant_outputs) 的 array_like

set_params(**params)

设置此估计器的参数。

此方法适用于简单估计器以及嵌套对象（例如 Pipeline）。嵌套对象的参数形式为 <component>__<parameter>，因此可以更新嵌套对象的每个组件。

参数: **params (dict) – 估计器参数。
返回: self – 估计器实例。
返回类型: 估计器实例