econml.utilities

工具方法。

函数

add_intercept(X)	通过在数组前面添加一列 1 来添加截距特征。
broadcast_unit_treatments(X, d_t)	为 X 的每一行生成 d_t 个单位处理。
check_high_dimensional(X, T, *, threshold[, ...])
check_input_arrays(*args[, validate_len, ...])	将输入序列转换为 numpy 数组。
check_inputs(Y, T, X[, W, multi_output_T, ...])	CATE 估计器的输入验证。
check_models(models, n)	元学习器模型的输入验证。
concatenate(XS[, axis])	沿着现有轴连接数组序列。
cross_product(*XS)	计算特征的叉积。
deprecated(message[, category])	允许修饰方法或类，在使用时提供警告。
einsum_sparse(subscripts, *arrs)	对操作数评估爱因斯坦求和约定。
filter_none_kwargs(**kwargs)	过滤掉任何值为 None 的关键字参数。
get_feature_names_or_default(featurizer, ...)	从 sklearn 转换器中提取特征名称。
get_input_columns(X[, prefix])	从类似 dataframe 的输入对象中提取列名。
hstack(XS)	水平堆叠数组（按列）。
inverse_onehot(T)	给定一个值的独热编码，返回一个向量来反转编码以获得数值处理索引。
iscoo(X)	确定输入是否为 sparse.COO 数组。
issparse(X)	确定输入是否为稀疏。
jacify_featurizer(featurizer)	接受特征器作为输入并返回一个包装器类的函数，该包装器类包含一个用于计算雅可比的函数
ndim(X)	返回数组的维度数。
one_hot_encoder([sparse])	sklearn 的 OneHotEncoder 包装器，用于处理 sklearn 1.1 和 1.2 版本之间从 sparse 到 sparse_output 的名称更改。
parse_final_model_params(coef, intercept, ...)
reshape(X, shape)	返回一个新的数组，它是输入数组的重塑版本。
reshape_Y_T(Y, T)	在 Y.ndim = 2 和/或 T.ndim = 1 时重塑 Y 和 T。
reshape_arrays_2dim(length, *args)	将输入数组重塑为二维。
reshape_treatmentwise_effects(A, d_t, d_y)	给定一个首先按处理排序的效应矩阵，将其转换为按结果排序。
shape(X)	返回数组维度的元组。
size(X)	返回数组中的元素数量。
stack(XS[, axis])	沿着新轴连接数组序列。
strata_from_discrete_arrays(arrs)	将多个离散数组组合成一个单一数组，用于分层目的
tensordot(X1, X2, axes)	对于 >= 1 维数组，沿着指定的轴计算张量点积。
tocoo(X)	将数组转换为稀疏 COO 数组。
todense(X)	将数组转换为密集 numpy 数组。
transpose(X[, axes])	置换数组的维度。
transpose_dictionary(d)	转置字典的字典，将第二层的键提到顶部，反之亦然
vstack(XS)	垂直堆叠数组（按行）。

类

IdentityFeatures()	仅返回输入数据的特征器。
MissingModule(msg, exn)	占位符，代表无法导入的模块，将 ImportError 延迟到使用时。
MultiModelWrapper([model_list])	用于为每个处理训练不同模型的辅助类。
SeparateModel(*models)	根据最后一个特征分割数据，并为每个子样本训练一个单独的模型。在预测时，它使用最后一个特征选择要用于预测的模型。
摘要()	结果摘要
WeightedModelWrapper(model_instance[, ...])	为没有权重的模型分配权重的辅助类。

class econml.utilities.IdentityFeatures

继承自: sklearn.base.TransformerMixin

仅返回输入数据的特征器。

fit(X)

Fit 方法（不执行任何操作，仅返回 self）。

fit_transform(X, y=None, **fit_params)

拟合数据，然后对其进行转换。

使用可选参数 fit_params 将转换器拟合到 X 和 y，并返回 X 的转换版本。

参数

• X (array-like, 形状为 (n_samples, n_features)) – 输入样本。

• y (array-like, 形状为 (n_samples,) 或 (n_samples, n_outputs)，默认为 None) – 目标值（对于无监督转换器为 None）。

• **fit_params (dict) – 其他拟合参数。

返回值

X_new – 转换后的数组。

返回类型

ndarray 数组，形状为 (n_samples, n_features_new)

set_output(*, transform=None)

设置输出容器。

有关如何使用 API 的示例，请参阅 Introducing the set_output API。

参数

transform ({“default”, “pandas”}, 默认为 None) – 配置 transform 和 fit_transform 的输出。

• “default”：转换器的默认输出格式

• “pandas”：DataFrame 输出

• None：转换配置保持不变

返回值

self – 估计器实例。

返回类型

估计器实例

transform(X)

执行恒等转换，该转换返回未修改的输入。

class econml.utilities.MissingModule(msg, exn)

继承自: object

占位符，代表无法导入的模块，将 ImportError 延迟到使用时。

参数

• msg (str) – 尝试访问模块成员时显示的消息

• exn (ImportError) – 作为异常源传递的原始 ImportError

class econml.utilities.MultiModelWrapper(model_list=[])

继承自: object

用于为每个处理训练不同模型的辅助类。

参数

model_list (array_like, 形状为 (n_T, )) – 为每个处理组单独训练的模型列表。

fit(Xt, y, sample_weight=None)

使用加权输入拟合底层模型列表。

参数

• X (array_like, 形状为 (n_samples, n_features + n_treatments)) – 训练数据。最后 n_T 列应为处理分配的独热编码。

• y (array_like, 形状为 (n_samples, )) – 目标值。

返回值

self

返回类型

类的一个实例

predict(Xt)

使用线性模型进行预测。

参数

X (array_like, 形状为 (n_samples, n_features + n_treatments)) – 样本。最后 n_T 列应为处理分配的独热编码。

返回值

C – 返回预测值。

返回类型

数组，形状为 (n_samples, )

class econml.utilities.SeparateModel(*models)

继承自: object

根据最后一个特征分割数据，并为每个子样本训练一个单独的模型。在预测时，它使用最后一个特征选择要用于预测的模型。

class econml.utilities.Summary

继承自: object

结果摘要

构造不接受任何参数。可以使用 add_ 方法添加表格和文本。

tables

包含 SimpleTable 实例的列表，水平连接的表格不单独保存。

类型

表格列表

extra_txt

添加到文本输出的额外行，用于警告和解释。

类型

str

add_extra_txt(etext)

添加附加文本，该文本将以文本格式添加到末尾

参数

etext (list[str]) – 添加到文本输出中的行的字符串。

as_csv()

返回表格作为字符串

返回值

csv – 以逗号分隔格式连接的汇总表

返回类型

str

as_html()

返回表格作为字符串

返回值

html – 以 HTML 格式连接的汇总表

返回类型

str

as_latex()

返回表格作为字符串

返回值

latex – 汇总表和额外文本的 Latex 字符串

返回类型

str

注意

这当前会合并列数不同的表格。建议直接在各个表格上使用 as_latex_tabular。

as_text()

返回表格作为字符串

返回值

txt – 汇总表和额外文本合并为一个字符串

返回类型

str

class econml.utilities.WeightedModelWrapper(model_instance, sample_type='weighted')

继承自: object

为没有权重的模型分配权重的辅助类。

参数

• model_instance (估计器) – 需要权重的模型。

• sample_type (str, 默认为 weighted) – 向模型添加权重的方法。对于权重可以合并到矩阵乘法中的线性回归模型，使用 weighted；对于其他模型，使用 sampled。sampled 根据归一化权重对训练集进行采样，并创建一个比原始数据集更大的数据集。

fit(X, y, sample_weight=None)

使用加权输入拟合底层模型实例。

参数

• X (array_like, 形状为 (n_samples, n_features)) – 训练数据。

• y (array_like, 形状为 (n_samples, n_outcomes)) – 目标值。

返回值

self

返回类型

底层估计器的一个实例。

predict(X)

使用线性模型进行预测。

参数

X (array_like 或稀疏矩阵, 形状为 (n_samples, n_features)) – 样本。

返回值

C – 返回预测值。

返回类型

数组, 形状为 (n_samples, n_outcomes)

econml.utilities.add_intercept(X)

通过在数组前面添加一列 1 来添加截距特征。

参数

X (array_like) – 输入数组。必须是二维的。

返回值

arr – X，在前面添加了一列 1

返回类型

ndarray

econml.utilities.broadcast_unit_treatments(X, d_t)

为 X 的每一行生成 d_t 个单位处理。

参数

• d_t (int) – 处理数量

• X (数组) – 特征

返回值

X, T – 更新后的 X 数组（每行重复 d_t 次）和生成的 T 数组

返回类型

(数组, 数组)

econml.utilities.check_input_arrays(*args, validate_len=True, force_all_finite=True, dtype=None)

将输入序列转换为 numpy 数组。

只有序列状的输入才会被转换，所有其他输入将保持原样。当 validate_len 为 True 时，将检查序列是否长度相等。

参数

• args (标量或 array_like) – 待检查的输入。

• validate_len (布尔值, 默认为 True) – 是否检查输入数组是否具有相同长度。

• force_all_finite (布尔值 或 ‘allow-nan’，默认为 True) – 是否允许输入数组中存在 inf 和 nan。‘allow-nan’：仅接受数组中的 np.nan 和 pd.NA 值。值不能是无限的。

• dtype (‘numeric’, type, list of type, 可选) – 传递给 sklearn.utils.check_array 的参数。指定结果的数据类型。如果为 None，则保留输入的 dtype。如果为“numeric”，则除非 array.dtype 为 object，否则保留 dtype。如果 dtype 是类型列表，则仅当输入的 dtype 不在列表中时才对第一个类型进行转换。

返回值

args – 序列状对象已转换为 numpy 数组的输入列表。

返回类型

array_like

econml.utilities.check_inputs(Y, T, X, W=None, multi_output_T=True, multi_output_Y=True, force_all_finite_X=True, force_all_finite_W=True)

CATE 估计器的输入验证。

检查 Y、T、X、W 的长度一致性，强制 X、W 为二维。标准输入检查仅适用于所有输入，例如检查输入是否不包含 np.nan 或 np.inf 目标。将常规 Python 列表转换为 numpy 数组。

参数

• Y (array_like, 形状为 (n, ) 或 (n, d_y)) – 处理策略的结果。

• T (array_like, 形状为 (n, ) 或 (n, d_t)) – 处理策略。

• X (array_like, 形状为 (n, d_x)) – 捕获异质性的特征向量。

• W (array_like, 形状为 (n, d_w), 可选) – 高维控制变量。

• multi_output_T (布尔值) – 是否允许存在多个处理。

• multi_output_Y (布尔值) – 是否允许存在多个结果。

• force_all_finite_X (布尔值 或 ‘allow-nan’，默认为 True) – 是否允许 X 的输入数组中存在 inf 和 nan。‘allow-nan’：仅接受数组中的 np.nan 和 pd.NA 值。值不能是无限的。

• force_all_finite_W (布尔值 或 ‘allow-nan’，默认为 True) – 是否允许 W 的输入数组中存在 inf 和 nan。‘allow-nan’：仅接受数组中的 np.nan 和 pd.NA 值。值不能是无限的。

返回值

• Y (array_like, 形状为 (n, ) 或 (n, d_y)) – 已转换和验证的 Y。

• T (array_like, 形状为 (n, ) 或 (n, d_t)) – 已转换和验证的 T。

• X (array_like, 形状为 (n, d_x)) – 已转换和验证的 X。

• W (array_like, 形状为 (n, d_w), 可选) – 已转换和验证的 W。

econml.utilities.check_models(models, n)

元学习器模型的输入验证。

检查输入模型是否满足以下条件。

参数

• models ： 估计器 或 估计器列表 或 元组

• n (int) – 所需模型数量

返回值

models

返回类型

list 或 估计器元组

econml.utilities.concatenate(XS, axis=0)

沿着现有轴连接数组序列。

参数

• X1, X2, … (array_like 序列) – 数组必须具有相同的形状，除了对应于 axis 的维度（默认为第一个）。

• axis (int, 可选) – 数组将沿着哪个轴连接。默认为 0。

返回值

连接后的数组。如果输入是稀疏的，则结果也将是稀疏的。

返回类型

ndarray 或 SparseArray

econml.utilities.cross_product(*XS)

计算特征的叉积。

参数

• X1 (n x d1 矩阵) – 包含 n 个样本和 d1 个特征的第一个矩阵（或一个 n 元素的向量，将被视为 n x 1 矩阵）

• X2 (n x d2 矩阵) – 包含 n 个样本和 d2 个特征的第二个矩阵（或一个 n 元素的向量，将被视为 n x 1 矩阵）

返回值

A – 包含 n 个样本和 d1*d2*… 叉积特征的矩阵，其排列形式使得 X12 的每一行 t 包含：[X1[t,0]*X2[t,0]*…, …, X1[t,d1-1]*X2[t,0]*…, X1[t,0]*X2[t,1]*…, …, X1[t,d1-1]*X2[t,1]*…, …]

返回类型

n x (d1*d2*…) 矩阵

econml.utilities.deprecated(message, category=<class 'FutureWarning'>)

允许修饰方法或类，在使用时提供警告。

参数

• message (str) – 要使用的弃用消息

• category (type, 默认为 FutureWarning) – 要使用的警告类别

econml.utilities.einsum_sparse(subscripts, *arrs)

对操作数评估爱因斯坦求和约定。

使用爱因斯坦求和约定，许多常见的多维数组操作可以以简单的方式表示。此函数提供了计算此类求和的方法。

参数

• subscripts (str) – 指定求和的下标。与 np.eisnum 不同，不支持省略号，并且必须明确包含输出

• arrs (list of sparse.COO) – 这些是操作的稀疏数组。

返回值

根据爱因斯坦求和约定计算的稀疏数组。

返回类型

SparseArray

econml.utilities.filter_none_kwargs(**kwargs)

过滤掉任何值为 None 的关键字参数。

当特定可选关键字参数可能并非普遍支持时，这很有用，因为它可以在未设置这些参数时将其移除，从而使更多用法能够成功。

参数

kwargs (dict) – 要过滤的关键字参数

返回值

filtered_kwargs – 输入字典，但移除了所有值为 None 的条目

返回类型

dict

econml.utilities.get_feature_names_or_default(featurizer, feature_names, prefix='feat(X)')

从 sklearn 转换器中提取特征名称。否则尝试分配默认特征名称。

设计用于兼容新旧 sklearn 版本。

参数

• featurizer ： 从中提取特征名称的特征器

• feature_names (str 序列) – 输入特征

• prefix (str, 默认为 “feat(X)”) – 分配默认特征名称时的输出前缀

返回值

feature_names_out – 特征名称

返回类型

str 列表

econml.utilities.get_input_columns(X, prefix='X')

从类似 dataframe 的输入对象中提取列名。

当前支持从 pandas DataFrame 和 Series 对象中提取列名。

参数

• X (array_like 或 None) – 要提取列名的输入数组。

• prefix (str, 默认为 “X”) – 如果输入数组没有列名，将返回使用命名方案 “{prefix}{column number}” 的默认值。

返回值

cols – 对应于类似 dataframe 对象的列列表。如果输入数组不在支持的类型中，则为 None。

返回类型

array_like 或 None

econml.utilities.hstack(XS)

水平堆叠数组（按列）。

这等同于沿着第二个轴进行连接

参数

XS (ndarray 序列) – 除了第二个轴之外，数组必须沿所有轴具有相同的形状。

返回值

由给定数组堆叠形成的数组。如果输入是稀疏的，则结果也将是稀疏的。

返回类型

ndarray 或 SparseArray

econml.utilities.inverse_onehot(T)

给定一个值的独热编码，返回一个向量来反转编码以获得数值处理索引。

注意，我们假设输入中已经移除了第一列。

参数

T (数组 (形状为 (n, d_t-1))) – 独热编码数组

返回值

A – 未编码的基于 0 的类别索引

返回类型

int 向量 (形状为 (n,))

econml.utilities.iscoo(X)

确定输入是否为 sparse.COO 数组。

参数

X (array_like) – 要检查的输入

返回值

输入是否为 COO 数组

返回类型

bool

econml.utilities.issparse(X)

确定输入是否为稀疏。

就本函数而言，scipy.sparse 矩阵和 sparse.SparseArray 类型均被视为稀疏。

参数

X (array_like) – 要检查的输入

返回值

输入是否稀疏

返回类型

bool

econml.utilities.jacify_featurizer(featurizer)

接受特征器作为输入并返回一个包装器类的函数，该包装器类包含一个用于计算雅可比的函数

econml.utilities.ndim(X)

返回数组的维度数。

econml.utilities.one_hot_encoder(sparse=False, **kwargs)

sklearn 的 OneHotEncoder 包装器，用于处理 sklearn 1.1 和 1.2 版本之间从 sparse 到 sparse_output 的名称更改。

econml.utilities.reshape(X, shape)

返回一个新的数组，它是输入数组的重塑版本。

当且仅当输入为稀疏时，输出才是稀疏的。

参数

• X (array_like) – 要重塑的数组

• shape (int 元组) – 输出数组的期望形状

返回值

重塑后的输出数组

返回类型

ndarray 或 SparseArray

econml.utilities.reshape_Y_T(Y, T)

在 Y.ndim = 2 和/或 T.ndim = 1 时重塑 Y 和 T。

参数

• Y (array_like, 形状为 (n, ) 或 (n, 1)) – 处理策略的结果。必须是向量或单列矩阵。

• T (array_like, 形状为 (n, ) 或 (n, d_t)) – 处理策略。

返回值

• Y (array_like, 形状为 (n, )) – 处理策略的展平结果。

• T (array_like, 形状为 (n, 1) 或 (n, d_t)) – 重塑后的处理策略。

econml.utilities.reshape_arrays_2dim(length, *args)

将输入数组重塑为二维。

参数

• length (标量) – 样本数量

• args (array_like 元组) – 要重塑的输入

返回值

new_args – 重塑数组的输出

返回类型

数组列表

econml.utilities.reshape_treatmentwise_effects(A, d_t, d_y)

给定一个首先按处理排序的效应矩阵，将其转换为按结果排序。

参数

• A (数组) – 效应数组，大小为 n*d_y*d_t

• d_t (int 元组) – 如果 T 是向量，则为 ()；如果 T 是数组，则为 T 列数的 1 元组

• d_y (int 元组) – 如果 Y 是向量，则为 ()；如果 Y 是数组，则为 Y 列数的 1 元组

返回值

A – 转换后的数组。请注意，对于作为向量的任何输入，将删除单例维度，如 BaseCateEstimator.marginal_effect 的规范所示。

返回类型

数组 (形状为 (m, d_y, d_t))

econml.utilities.shape(X)

返回数组维度的元组。

econml.utilities.size(X)

返回数组中的元素数量。

参数

a (array_like) – 输入数据

返回值

数组中的元素数量

返回类型

int

econml.utilities.stack(XS, axis=0)

沿着新轴连接数组序列。

axis 参数指定结果维度中新轴的索引。例如，如果 axis=0，则它将是第一个维度；如果 axis=-1，则它将是最后一个维度。

参数

• arrays (array_like 序列) – 每个数组必须具有相同的形状

• axis (int, 可选) – 输入数组在结果数组中沿着哪个轴堆叠

返回值

堆叠后的数组，比输入数组多一个维度。如果输入是稀疏的，则结果也将是稀疏的。

返回类型

ndarray 或 SparseArray

econml.utilities.strata_from_discrete_arrays(arrs)

将多个离散数组组合成一个单一数组，用于分层目的

例如，如果 arrs 为 [0 1 2 0 1 2 0 1 2 0 1 2], [0 1 0 1 0 1 0 1 0 1 0 1], [0 0 0 0 0 0 1 1 1 1 1 1]，则输出将是 [0 8 4 6 2 10 1 9 5 7 3 11]

这些离散数组的每一个不同组合都将拥有自己的标签。

econml.utilities.tensordot(X1, X2, axes)

对于 >= 1 维数组，沿着指定的轴计算张量点积。

参数

• X1, X2 (array_like, len(shape) >= 1) – 要进行“点积”的张量

• axes (int or (2,) array_like) –

  integer_like

  如果是一个整数 N，则按顺序对 X1 的最后 N 个轴和 X2 的前 N 个轴求和。对应轴的大小必须匹配

  (2,) array_like

  或者，一个要对其求和的轴列表，第一个序列应用于 X1，第二个序列应用于 X2。两个 array_like 元素必须具有相同的长度。

econml.utilities.tocoo(X)

将数组转换为稀疏 COO 数组。

如果输入已经是 sparse.COO 对象，则直接返回该对象；否则将其转换。

econml.utilities.todense(X)

将数组转换为密集 numpy 数组。

如果输入已经是 numpy 数组，这可能会创建新的副本。

econml.utilities.transpose(X, axes=None)

置换数组的维度。

参数

• X (array_like) – 输入数组。

• axes (list of int, optional) – 默认情况下反转维度，否则根据给定值对轴进行置换

返回值

p – 轴已置换的 X。如果 X 是稀疏的，则结果也将是稀疏的。

返回类型

ndarray 或 SparseArray

econml.utilities.transpose_dictionary(d)

转置字典的字典，将第二层的键提到顶部，反之亦然

参数

d (dict) – 要转置的字典；此字典的值本身都应是字典

返回值

output – 交换了一级和二级键的输出字典

返回类型

dict

econml.utilities.vstack(XS)

垂直堆叠数组（按行）。

这等价于将形状为 (N,) 的一维数组重塑为 (1,N) 后沿着第一个轴进行拼接。

参数

XS (sequence of ndarray) – 除了第一个轴以外，这些数组必须具有相同的形状。一维数组必须具有相同的长度。

返回值

通过堆叠给定数组形成的数组，至少将是二维的。如果输入是稀疏的，它也将是稀疏的。

返回类型

ndarray 或 SparseArray