转换器#

转换数据的组件。

子模块#

包内容#

类摘要#

`DateTimeFeaturizer`	可以自动从日期时间列中提取特征的转换器。
`DFSTransformer`	Featuretools DFS 组件，为输入特征生成特征。
`DropColumns`	删除输入数据中指定的列。
`DropNaNRowsTransformer`	删除包含 NaN 值的行的转换器。
`DropNullColumns`	删除 NaN 值百分比超过指定阈值的特征的转换器。
`DropRowsTransformer`	根据行索引删除行的转换器。
`EmailFeaturizer`	可以自动从电子邮件中提取特征的转换器。
`FeatureSelector`	根据重要性权重选择排名靠前的特征。
`Imputer`	根据指定的填充策略填充缺失数据。
`LabelEncoder`	一个使用 0 到 num_classes - 1 之间的值对目标标签进行编码的转换器。
`LinearDiscriminantAnalysis`	使用线性判别分析减少特征数量。
`LogTransformer`	对目标数据应用对数变换。
`LSA`	计算文本输入的潜在语义分析值的转换器。
`NaturalLanguageFeaturizer`	可以使用 featuretools 的 nlp_primitives 自动对文本列进行特征化的转换器。
`OneHotEncoder`	一个将分类特征编码为独热数字数组的转换器。
`OrdinalEncoder`	一个将有序特征编码为表示类别相对顺序的有序整数数组的转换器。
`Oversampler`	SMOTE 过采样器组件。将根据组件的输入自动选择使用 SMOTE、SMOTEN 或 SMOTENC。
`PCA`	使用主成分分析 (PCA) 减少特征数量。
`PerColumnImputer`	根据指定的每列填充策略填充缺失数据。
`PolynomialDecomposer`	通过拟合多项式和移动平均线来去除时间序列中的趋势和季节性。
`ReplaceNullableTypes`	用于将具有新可空 dtype 的特征替换为 EvalML 中兼容 dtype 的转换器。
`RFClassifierRFESelector`	使用带有随机森林分类器的递归特征消除来选择相关特征。
`RFClassifierSelectFromModel`	使用随机森林分类器根据重要性权重选择排名靠前的特征。
`RFRegressorRFESelector`	使用带有随机森林回归器的递归特征消除来选择相关特征。
`RFRegressorSelectFromModel`	使用随机森林回归器根据重要性权重选择排名靠前的特征。
`SelectByType`	根据输入数据中指定的 Woodwork 逻辑类型或语义标签选择列。
`SelectColumns`	选择输入数据中指定的列。
`SimpleImputer`	根据指定的填充策略填充缺失数据。忽略自然语言列。
`StandardScaler`	一个通过移除均值和缩放到单位方差来标准化输入特征的转换器。
`STLDecomposer`	使用 STL 算法从时间序列中去除趋势和季节性。
`TargetEncoder`	一个将分类特征编码为目标编码的转换器。
`TargetImputer`	根据指定填充策略填充缺失目标数据。
`TimeSeriesFeaturizer`	为时间序列问题延迟输入特征和目标变量的转换器。
`TimeSeriesImputer`	根据指定的时间序列特定填充策略填充缺失数据。
`TimeSeriesRegularizer`	对不规则间隔的日期时间列进行正则化的转换器。
`Transformer`	一个可能或可能不需要拟合来转换数据的组件。这些组件在估计器之前使用。
`Undersampler`	初始化一个欠采样转换器，以对数据集中的多数类进行下采样。
`URLFeaturizer`	可以自动从 URL 中提取特征的转换器。

目录#

class evalml.pipelines.components.transformers.DateTimeFeaturizer(features_to_extract=None, encode_as_categories=False, time_index=None, random_seed=0, **kwargs)[源码]#

可以自动从日期时间列中提取特征的转换器。

参数

features_to_extract (列表) – 要提取的特征列表。有效选项包括“year”、“month”、“day_of_week”、“hour”。默认为 None。
encode_as_categories (布尔值) – 周几和月份特征是否应编码为 pandas 的“category”dtype。这允许独热编码器对这些特征进行编码。默认为 False。
time_index (字符串) – 包含用于对数据排序的日期时间信息的列名。忽略。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	日期时间特征提取器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合日期时间特征提取器组件。
`拟合转换`	在 X 上拟合并转换 X。
`获取特征名称`	获取每个日期时间特征的类别。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过使用现有日期时间列创建新特征，然后删除这些日期时间列来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

拟合日期时间特征提取器组件。

参数

X (pd.DataFrame) – 输入特征。
y (pd.Series, 可选) – 目标数据。忽略。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

get_feature_names(self)[源码]#

获取每个日期时间特征的类别。

返回

字典，其中每个键值对是一个列名和一个字典: 将唯一特征值映射到其整数编码。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

通过使用现有日期时间列创建新特征，然后删除这些日期时间列来转换数据 X。

参数

X (pd.DataFrame) – 输入特征。
y (pd.Series, 可选) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.DFSTransformer(index='index', features=None, random_seed=0, **kwargs)[源码]#

Featuretools DFS 组件，为输入特征生成特征。

参数

index (字符串) – 包含索引的列的名称。如果不存在具有此名称的列，则 featuretools.EntitySet() 会创建一个具有此名称的列作为索引列。默认为“index”。
random_seed (整数) – 随机数生成器的种子。默认为 0。
features (列表) – 要运行 DFS 的特征列表。默认为 None。只有当特征使用的列存在于输入中且特征本身不在输入中时，才会计算特征。如果 features 是一个空列表，则不会对输入数据进行转换。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	DFS 转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`包含现有特征`	确定 DFS 转换器的特征是否与管道输入特征匹配。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 DFSTransformer 转换器组件。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用 featuretools 的 dfs 算法计算输入 X 的特征矩阵。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

static contains_pre_existing_features(dfs_features: Optional[List[featuretools.feature_base.FeatureBase]], input_feature_names: List[str], target: Optional[str] = None)[源码]#

确定 DFS 转换器的特征是否与管道输入特征匹配。

参数

dfs_features (可选[List[FeatureBase]]) – DFS 转换器输出的特征列表。
input_feature_names (List[str]) – 输入到 DFS 转换器中的输入特征列表。
target (可选[str]) – 我们试图预测其值的目标。如果目标列存在于 DFS 转换器参数中的特征列表中，则用于忽略该列。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

拟合 DFSTransformer 转换器组件。

参数

X (pd.DataFrame, np.array) – 要转换的输入数据，形状为 [n_samples, n_features]。
y (pd.Series) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

使用 featuretools 的 dfs 算法计算输入 X 的特征矩阵。

参数

X (pd.DataFrame 或 np.ndarray) – 要转换的输入训练数据。形状为 [n_samples, n_features]
y (pd.Series, 可选) – 忽略。

返回

特征矩阵

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.DropColumns(columns=None, random_seed=0, **kwargs)[源码]#

删除输入数据中指定的列。

参数

columns (list(字符串)) – 列名列表，用于确定要删除的列。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	删除列转换器
需要拟合	False
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	通过检查数据集中是否存在列名来拟合转换器。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过删除列来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

通过检查数据集中是否存在列名来拟合转换器。

参数

X (pd.DataFrame) – 要检查的数据。
y (pd.Series, 忽略) – 目标。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

通过删除列来转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标。

返回

转换后的 X。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.DropNaNRowsTransformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[源码]#

删除包含 NaN 值的行的转换器。

参数: random_seed (整数) – 随机数生成器的种子。此组件不使用此参数。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	True
名称	删除 NaN 行转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用拟合的组件转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

使用拟合的组件转换数据。

参数

X (pd.DataFrame) – 特征。
y (pd.Series, 可选) – 目标数据。

返回

删除了 NaN 行的数据。

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.DropNullColumns(pct_null_threshold=1.0, random_seed=0, **kwargs)[源码]#

删除 NaN 值百分比超过指定阈值的特征的转换器。

参数

pct_null_threshold (浮点数) – 输入特征中要删除的 NaN 值百分比。必须是 [0, 1]（包含）之间的值。如果等于 0.0，将删除包含任何空值的列。如果等于 1.0，将删除包含所有空值的列。默认为 0.95。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	删除空列转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过删除超过空值阈值的列来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

通过删除超过空值阈值的列来转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据
y (pd.Series, 可选) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.DropRowsTransformer(indices_to_drop=None, random_seed=0)[源码]#

根据行索引删除行的转换器。

参数

indices_to_drop (列表) – 输入数据中要删除的索引列表。默认为 None。
random_seed (整数) – 随机数生成器的种子。此组件不使用此参数。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	True
名称	删除行转换器
仅训练	True

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用拟合的组件转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果要删除的索引在输入特征或目标中不存在。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

使用拟合的组件转换数据。

参数

X (pd.DataFrame) – 特征。
y (pd.Series, 可选) – 目标数据。

返回

删除了行索引的数据。

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.EmailFeaturizer(random_seed=0, **kwargs)[源码]#

可以自动从电子邮件中提取特征的转换器。

参数: random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	电子邮件特征提取器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.FeatureSelector(parameters=None, component_obj=None, random_seed=0, **kwargs)[源码]#

根据重要性权重选择排名靠前的特征。

参数

parameters (dict) – 组件的参数字典。默认为 None。
component_obj (对象) – 在组件实现中有用的第三方对象。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

修改特征	True
修改目标	False
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`获取名称`	获取所选特征的名称。
`加载`	从文件路径加载组件。
`名称`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)[源码]#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)[源码]#

获取所选特征的名称。

返回: 所选特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property name(cls)#: 返回此组件的字符串名称。

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或实现了 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.Imputer(categorical_impute_strategy='most_frequent', categorical_fill_value=None, numeric_impute_strategy='mean', numeric_fill_value=None, boolean_impute_strategy='most_frequent', boolean_fill_value=None, random_seed=0, **kwargs)[源码]#

根据指定的填充策略填充缺失数据。

参数

categorical_impute_strategy (字符串) – 用于字符串、对象、布尔值、分类 dtype 的填充策略。有效值包括“most_frequent”和“constant”。
numeric_impute_strategy (字符串) – 用于数值列的填充策略。有效值包括“mean”、“median”、“most_frequent”和“constant”。
boolean_impute_strategy (字符串) – 用于布尔列的填充策略。有效值包括“most_frequent”和“constant”。
categorical_fill_value (字符串) – 当 categorical_impute_strategy == “constant”时，fill_value 用于替换缺失数据。默认值 None 将填充为字符串“missing_value”。
numeric_fill_value (整数, 浮点数) – 当 numeric_impute_strategy == “constant”时，fill_value 用于替换缺失数据。默认值 None 将填充为 0。
boolean_fill_value (布尔值) – 当 boolean_impute_strategy == “constant”时，fill_value 用于替换缺失数据。默认值 None 将填充为 True。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “categorical_impute_strategy”: [“most_frequent”], “numeric_impute_strategy”: [“mean”, “median”, “most_frequent”, “knn”], “boolean_impute_strategy”: [“most_frequent”]}
修改特征	True
修改目标	False
名称	Imputer
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将填充器拟合到数据。“None”值在填充前转换为 np.nan，并被视为相同。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过填充缺失值来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[源码]#

将填充器拟合到数据。“None”值在填充前转换为 np.nan，并被视为相同。

参数

X (pd.DataFrame, np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[源码]#

通过填充缺失值来转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据
y (pd.Series, 可选) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.LabelEncoder(positive_label=None, random_seed=0, **kwargs)[源码]#

一个使用 0 到 num_classes - 1 之间的值对目标标签进行编码的转换器。

参数

positive_label (整数, 字符串) – 对于二元分类问题，应被视为正类（1）的标签。对于多分类问题忽略。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。忽略。

属性

超参数范围	{}
修改特征	False
修改目标	True
名称	标签编码器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合标签编码器。
`拟合转换`	使用标签编码器拟合和转换数据。
`逆转换`	解码目标数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用拟合的标签编码器转换目标。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

拟合标签编码器。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。忽略。
y (pd.Series) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果输入 y 为 None。

fit_transform(self, X, y)[source]#

使用标签编码器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series) – 长度为 [n_samples] 的目标训练数据。

返回

原始特征和目标变量的编码版本。

返回类型

pd.DataFrame, pd.Series

inverse_transform(self, y)[source]#

解码目标数据。

参数: y (pd.Series) – 目标数据。
返回: 目标变量的解码版本。
返回类型: pd.Series
抛出: ValueError – 如果输入 y 为 None。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用拟合的标签编码器转换目标。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。忽略。
y (pd.Series) – 长度为 [n_samples] 的目标训练数据。

返回

原始特征和目标变量的编码版本。

返回类型

pd.DataFrame, pd.Series

抛出

ValueError – 如果输入 y 为 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.LinearDiscriminantAnalysis(n_components=None, random_seed=0, **kwargs)[source]#

使用线性判别分析减少特征数量。

参数

n_components (int) – 计算后保留的特征数量。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	线性判别分析（Linear Discriminant Analysis）转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 LDA 组件。
`拟合转换`	使用 LDA 组件拟合并转换数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用已拟合的 LDA 组件转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

拟合 LDA 组件。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果输入数据并非全部为数值类型。

fit_transform(self, X, y=None)[source]#

使用 LDA 组件拟合并转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

抛出

ValueError – 如果输入数据并非全部为数值类型。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用已拟合的 LDA 组件转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

抛出

ValueError – 如果输入数据并非全部为数值类型。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.LogTransformer(random_seed=0)[source]#

对目标数据应用对数变换。

属性

超参数范围	{}
修改特征	False
修改目标	True
名称	对数转换器（Log Transformer）
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 LogTransformer。
`拟合转换`	对目标变量应用对数变换。
`逆转换`	对目标数据应用指数变换。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	对目标变量应用对数变换。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 LogTransformer。

参数

X (pd.DataFrame or np.ndarray) – 忽略。
y (pd.Series, 可选) – 忽略。

返回

self

fit_transform(self, X, y=None)[source]#

对目标变量应用对数变换。

参数

X (pd.DataFrame, optional) – 忽略。
y (pd.Series) – 需要进行对数变换的目标变量。

返回

输入特征将不做修改地返回。目标变量: y 会进行对数变换。

返回类型

tuple of pd.DataFrame, pd.Series

inverse_transform(self, y)[source]#

对目标数据应用指数变换。

参数: y (pd.Series) – 目标变量。
返回: 应用指数变换后的目标变量。
返回类型: pd.Series

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

对目标变量应用对数变换。

参数

X (pd.DataFrame, optional) – 忽略。
y (pd.Series) – 需要进行对数变换的目标数据。

返回

输入特征将不做修改地返回。目标变量: y 会进行对数变换。

返回类型

tuple of pd.DataFrame, pd.Series

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.LSA(random_seed=0, **kwargs)[source]#

计算文本输入的潜在语义分析值的转换器。

参数: random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	LSA 转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合输入数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过应用 LSA 管道来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合输入数据。

参数

X (pd.DataFrame) – 需要转换的数据。
y (pd.Series, 可选) – 忽略。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过应用 LSA 管道来转换数据 X。

参数

X (pd.DataFrame) – 需要转换的数据。
y (pd.Series, 可选) – 忽略。

返回

转换后的 X。原始列被移除，替换为两列新的列，其格式为: 格式 LSA(original_column_name)[feature_number]，其中 feature_number 为 0 或 1。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.NaturalLanguageFeaturizer(random_seed=0, **kwargs)[source]#

能够使用 featuretools 的 nlp_primitives 自动对文本列进行特征化的转换器。

由于模型无法处理非数值数据，任何文本都必须分解为能够提供有关该文本有用信息的特征。此组件将每个文本列分割成几个信息丰富的特征：多样性分数（Diversity Score）、每个词的平均字符数（Mean Characters per Word）、极性分数（Polarity Score）、LSA（潜在语义分析）、字符数（Number of Characters）和词数（Number of Words）。对此组件调用 transform 方法会将给定数据集中的任何文本列替换为这些数值列。

参数: random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	自然语言特征提取器（Natural Language Featurizer）
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过使用现有文本列创建新特征来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将组件拟合到数据。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据
y (pd.Series) – 长度为 [n_samples] 的目标训练数据

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过使用现有文本列创建新特征来转换数据 X。

参数

X (pd.DataFrame) – 需要转换的数据。
y (pd.Series, 可选) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.OneHotEncoder(top_n=10, features_to_encode=None, categories=None, drop='if_binary', handle_unknown='ignore', handle_missing='error', random_seed=0, **kwargs)[source]#

一个将分类特征编码为独热数字数组的转换器。

参数

top_n (int) – 每列要编码的类别数量。如果为 None，所有类别都将被编码。否则，将编码 n 个最常见的类别，并丢弃所有其他类别。默认为 10。
features_to_encode (list[str]) – 需要编码的列列表。所有其他列将保持不变。如果为 None，将编码所有适当的列。默认为 None。
categories (list) – 一个二维类别列表，其中 categories[i] 是索引 i 处列的类别列表。如果 top_n 不为 None，此参数也可以是 None 或 “auto”。默认为 None。
drop (string, list) – 用于丢弃每个特征的一个类别的方法（“first” 或 “if_binary”）。也可以是指定每个特征要丢弃哪些类别的列表。默认为 ‘if_binary’。
handle_unknown (string) – 在 fit 或 transform 期间遇到未知特征类别时是忽略还是报错。如果使用 top_n 或 categories 来限制每列的类别数量，则此参数必须为 “ignore”。默认为 “ignore”。
handle_missing (string) – 在 fit 或 transform 期间遇到缺失值 (NaN) 时的处理选项。如果设置为 “as_category” 且 NaN 值在前 n 个最常见的类别中，则 “nan” 值将作为其自己的列进行编码。如果设置为 “error”，则遇到的任何缺失值都将引发错误。默认为 “error”。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	One Hot 编码器（One Hot Encoder）
仅训练	False

方法

`类别`	返回特定特征要编码的唯一类别列表，按顺序排列。
`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 One Hot 编码器组件。
`拟合转换`	在 X 上拟合并转换 X。
`获取特征名称`	拟合后返回类别特征的特征名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	对输入数据进行 One Hot 编码。
`更新参数`	更新组件的参数字典。

categories(self, feature_name)[source]#

返回特定特征要编码的唯一类别列表，按顺序排列。

参数: feature_name (str) – 在拟合期间提供给 One Hot 编码器的任何特征的名称。
返回: 唯一类别，与拟合期间提供的 dtype 相同。
返回类型: np.ndarray
抛出: ValueError – 如果未将特征作为训练特征提供给 One Hot 编码器。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 One Hot 编码器组件。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果编码列失败。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

get_feature_names(self)[source]#

拟合后返回类别特征的特征名称。

特征名称的格式为 {列名}_{类别名}。如果名称重复，将在特征名称末尾添加一个整数以区分。

例如，考虑一个数据帧，其中一列名为“A”，类别为“x_y”，另一列名为“A_x”，类别为“y”。在此示例中，特征名称将是“A_x_y”和“A_x_y_1”。

返回: 编码后的特征名称，按照 input_features 的相同顺序提供。
返回类型: np.ndarray

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

对输入数据进行 One Hot 编码。

参数

X (pd.DataFrame) – 需要进行 One Hot 编码的特征。
y (pd.Series) – 忽略。

返回

转换后的数据，其中每个类别特征已使用 One Hot 编码转换为数值列。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.OrdinalEncoder(features_to_encode=None, categories=None, handle_unknown='error', unknown_value=None, encoded_missing_value=None, random_seed=0, **kwargs)[source]#

一个将有序特征编码为表示类别相对顺序的有序整数数组的转换器。

参数

features_to_encode (list[str]) – 需要编码的列列表。所有其他列将保持不变。如果为 None，将编码所有适当的列。默认为 None。列的顺序无关紧要。
categories (dict[str, list[str]]) – 一个字典，将列名映射到在 fit 和 transform 中传入的数据帧中的对应类别。为列指定的类别顺序无关紧要。数据中找到的任何不在 categories 中出现的类别将被视为未知值处理。为避免未知值引发错误，请将 handle_unknown 设置为 “use_encoded_value”。默认为 None。
handle_unknown ("error" or "use_encoded_value") – 在 fit 或 transform 期间遇到未知特征类别时是忽略还是报错。设置为 “error” 时，遇到未知类别会引发错误。设置为 “use_encoded_value” 时，未知类别将编码为 unknown_value 参数给定的值。默认为 “error.”
unknown_value (int or np.nan) – 在 fit 或 transform 期间遇到的未知类别使用的值。当参数 handle_unknown 设置为 “use_encoded_value” 时必需。该值必须与 fit 中用于编码任何类别的所有值不同。默认为 None。
encoded_missing_value (int or np.nan) – 在 fit 或 transform 期间遇到的缺失值 (null) 使用的值。默认为 np.nan。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	有序编码器（Ordinal Encoder）
仅训练	False

方法

`类别`	返回特定特征要编码的唯一类别列表，按顺序排列。
`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合有序编码器组件。
`拟合转换`	在 X 上拟合并转换 X。
`获取特征名称`	拟合后返回有序特征的特征名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	对输入数据进行有序编码。
`更新参数`	更新组件的参数字典。

categories(self, feature_name)[source]#

返回特定特征要编码的唯一类别列表，按顺序排列。

参数: feature_name (str) – 在拟合期间提供给有序编码器的任何特征的名称。
返回: 唯一类别，与拟合期间提供的 dtype 相同。
返回类型: np.ndarray
抛出: ValueError – 如果未将特征作为训练特征提供给有序编码器。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合有序编码器组件。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果编码列失败。
TypeError – 如果在 features_to_encode 中指定了非有序列。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

get_feature_names(self)[source]#

拟合后返回有序特征的特征名称。

特征名称的格式为 {列名}_ordinal_encoding。

返回: 编码后的特征名称，按照 input_features 的相同顺序提供。
返回类型: np.ndarray

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

对输入数据进行有序编码。

参数

X (pd.DataFrame) – 需要编码的特征。
y (pd.Series) – 忽略。

返回

转换后的数据，其中每个有序特征已编码为一个数值列，有序整数表示类别的相对顺序。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.Oversampler(sampling_ratio=0.25, sampling_ratio_dict=None, k_neighbors_default=5, n_jobs=-1, random_seed=0, **kwargs)[source]#

SMOTE 过采样器组件。将根据组件的输入自动选择使用 SMOTE、SMOTEN 或 SMOTENC。

参数

sampling_ratio (float) – 这是少数类与多数类的目标比例，范围为 (0, 1]。值为 0.25 表示我们希望在过采样后少数类与多数类的比例为 1:4。我们将使用此比例创建一个采样字典，其中键对应于类别，值对应于样本数量。默认为 0.25。
sampling_ratio_dict (dict) – 一个字典，指定每个目标值的期望平衡比例。例如，在二元分类中，如果类别 1 是少数类，我们可以指定：sampling_ratio_dict={0: 0.5, 1: 1}，这意味着我们将对类别 0 进行欠采样，使其样本数量是类别 1 的两倍（少数类:多数类比例 = 0.5），并且不对类别 1 进行采样。如果提供了此参数，将覆盖 sampling_ratio。默认为 None。
k_neighbors_default (int) – 用于构建合成样本的最近邻数量。这是使用的默认值，但如果样本较少，实际的 k_neighbors 值可能会更小。默认为 5。
n_jobs (int) – 使用的 CPU 核心数。默认为 -1。
random_seed (int) – 用于随机采样的种子。默认为 0。

属性

超参数范围	None
修改特征	True
修改目标	True
名称	Oversampler
仅训练	True

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将过采样器拟合到数据。
`拟合转换`	使用采样器组件拟合并转换数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过对数据进行过采样来转换输入数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

将过采样器拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y)#

使用采样器组件拟合并转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

(pd.DataFrame, pd.Series)

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过对数据进行过采样来转换输入数据。

参数

X (pd.DataFrame) – 训练特征。
y (pd.Series) – 目标变量。

返回

转换后的特征和目标变量。

返回类型

pd.DataFrame, pd.Series

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.PCA(variance=0.95, n_components=None, random_seed=0, **kwargs)[source]#

使用主成分分析 (PCA) 减少特征数量。

参数

variance (float) – 减少特征数量时应保留的原始数据方差百分比。默认为 0.95。
n_components (int) – 计算 SVD 后保留的特征数量。默认为 None，但如果设置了此参数，将覆盖 variance 变量。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	实数(0.25, 1)}:类型: {“方差”
修改特征	True
修改目标	False
名称	PCA 转换器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 PCA 组件。
`拟合转换`	使用 PCA 组件拟合并转换数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用已拟合的 PCA 组件转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 PCA 组件。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果输入数据并非全部为数值类型。

fit_transform(self, X, y=None)[source]#

使用 PCA 组件拟合并转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

抛出

ValueError – 如果输入数据并非全部为数值类型。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用已拟合的 PCA 组件转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

抛出

ValueError – 如果输入数据并非全部为数值类型。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.PerColumnImputer(impute_strategies=None, random_seed=0, **kwargs)[source]#

根据指定的每列填充策略填充缺失数据。

参数

impute_strategies (dict) – 列和 {“impute_strategy”: 策略, “fill_value”: 值} 的配对。数值数据的有效填充策略值包括 “mean”, “median”, “most_frequent”, “constant”，对象数据类型的有效值包括 “most_frequent”, “constant”。默认为 None，此时对所有列使用 “most_frequent”。当 impute_strategy == “constant” 时，fill_value 用于替换缺失数据。当为 None 时，对数值数据使用 0 进行填充，对字符串或对象数据类型使用 “missing_value”。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	按列填充器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	在输入数据上拟合填充器。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过填充缺失值来转换输入数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

在输入数据上拟合填充器。

参数

X (pd.DataFrame 或 np.ndarray) – 要拟合的输入训练数据，形状为 [样本数, 特征数]。
y (pd.Series, 可选) – 目标训练数据，长度为 [样本数]。被忽略。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过填充缺失值来转换输入数据。

参数

X (pd.DataFrame 或 np.ndarray) – 要转换的输入训练数据，形状为 [样本数, 特征数]。
y (pd.Series, 可选) – 目标训练数据，长度为 [样本数]。被忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.PolynomialDecomposer(time_index: str = None, degree: int = 1, period: int = -1, random_seed: int = 0, **kwargs)[source]#

通过拟合多项式和移动平均线来去除时间序列中的趋势和季节性。

使用 Scikit-learn 的 PolynomialForecaster 生成目标数据的加性趋势部分。在 fit 期间，将拟合一个多项式到数据上。

该加性多项式趋势将在 fit 期间移除，以便 statsmodel 的 seasonal_decompose 可以通过对序列的推断周期性使用移动平均来确定数据的加性季节性。

例如，日时间序列数据将生成数据第一周的移动平均，标准化出均值，并返回在给定序列的整个长度上重复的这 7 个平均值。这 7 个平均值根据需要重复多次以匹配给定目标数据的长度，将用作数据的季节性信号。

参数

time_index (str) – 指定 X 中提供 datetime 对象的列的名称。默认为 None。
degree (int) – 多项式的次数。如果为 1，则将线性模型拟合到数据上。如果为 2，则拟合二次模型等。默认为 1。
period (int) – 时间序列数据中对应于循环信号一个周期的条目数。例如，如果已知数据具有每周季节性信号，并且数据是日数据，则 period 应为 7。对于具有年度季节性信号的日数据，period 应为 365。默认为 -1，此时使用 statsmodels 库的 freq_to_period 函数。statsmodels/statsmodels
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “degree”: Integer(1, 3)}
无效频率 (invalid_frequencies)	[]
修改特征	False
修改目标	True
名称	多项式分解器 (Polynomial Decomposer)
需要拟合	True
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`确定周期性 (determine_periodicity)`	使用自相关方法确定季节性信号最显著周期的函数。
`拟合`	拟合 PolynomialDecomposer 并确定季节性信号。
`拟合转换`	从目标变量中移除拟合的趋势和季节性。
`获取趋势 DataFrame (get_trend_dataframe)`	返回一个包含 4 列的 DataFrame 列表：signal, trend, seasonality, residual。
`逆转换`	将拟合的趋势和季节性添加回目标变量。
`频率是否有效 (is_freq_valid)`	确定给定字符串是否代表此分解器有效的频率。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`绘制分解图 (plot_decomposition)`	绘制目标信号的分解图。
`保存`	将组件保存到文件路径。
`设置周期 (set_period)`	根据目标的季节性设置组件季节性周期的函数。
`转换`	通过移除多项式趋势和移动平均季节性来转换目标数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

classmethod determine_periodicity(cls, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

使用自相关方法确定季节性信号最显著周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于阈值的任何值都被视为 0，不考虑用于周期确定。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

返回

时间序列数据中条目的整数数量，目标数据的季节性部分在此周期内重复。: 如果时间序列数据是日数据，则这是目标季节性信号重复所需的天数。注意：目标数据可以包含多个季节性信号。此函数仅返回更强的那个。例如，如果目标既有每周季节性又有年度季节性，函数可能返回“7”或“365”，具体取决于哪种季节性具有更强的自相关性。如果未检测到周期，则返回 None。

返回类型

int

fit(self, X: pandas.DataFrame, y: pandas.Series = None) → PolynomialDecomposer[source]#

拟合 PolynomialDecomposer 并确定季节性信号。

当前仅拟合多项式去趋势器。季节性是通过从信号中移除趋势并使用 statsmodels 的 seasonal_decompose() 来确定的。趋势和季节性当前都被假定为可加的。

参数

X (pd.DataFrame, 可选) – 有条件地用于构建 datetime 索引。
y (pd.Series) – 用于去趋势和去季节化的目标变量。

返回

self

抛出

NotImplementedError – 如果输入数据的频率是“month-begin”。statsmodels decompose 不支持此操作，因为 freqstr “MS” 被错误地解释为毫秒。
ValueError – 如果 y 是 None。
ValueError – 如果目标数据没有 DatetimeIndex *并且*特征数据中没有 Datetime 特征

fit_transform(self, X: pandas.DataFrame, y: pandas.Series = None) → tuple[pandas.DataFrame, pandas.Series]#

从目标变量中移除拟合的趋势和季节性。

参数

X (pd.DataFrame, optional) – 忽略。
y (pd.Series) – 用于去趋势和去季节化的目标变量。

返回

第一个元素是未经修改返回的输入特征。: 第二个元素是移除了拟合趋势的目标变量 y。

返回类型

tuple of pd.DataFrame, pd.Series

get_trend_dataframe(self, X: pandas.DataFrame, y: pandas.Series) → list[pandas.DataFrame][source]#

返回一个包含 4 列的 DataFrame 列表：signal, trend, seasonality, residual。

使用 Scikit-learn 的 PolynomialForecaster 生成目标数据的趋势部分。使用 statsmodel 的 seasonal_decompose 生成数据的季节性。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series 或 pd.DataFrame) – 作为 Series 提供的目标变量数据用于单变量问题，或作为 DataFrame 提供的目标变量数据用于多变量问题。

返回

每个 DataFrame 包含列 “signal”, “trend”, “seasonality” 和 “residual”，: 后 3 列的值是目标数据的分解元素。“signal” 列仅仅是输入目标信号，但使用 datetime 索引重新索引以匹配输入特征。

返回类型

pd.DataFrame 列表

抛出

TypeError – 如果 X 的索引中不包含时间序列数据。
ValueError – 如果 X 的时间序列索引没有推断的频率。
ValueError – 如果与去趋势器关联的预测器尚未拟合。
TypeError – 如果 y 未作为 pandas Series 或 DataFrame 提供。

inverse_transform(self, y_t: pandas.Series) → tuple[pandas.DataFrame, pandas.Series][source]#

将拟合的趋势和季节性添加回目标变量。

将多项式趋势添加回信号中，调用去趋势器的 inverse_transform() 方法。然后，将季节性向前投影并添加回信号中。

参数

y_t (pd.Series) – 目标变量。

返回

第一个元素是未经修改返回的输入特征。: 第二个元素是添加回趋势和季节性的目标变量 y。

返回类型

tuple of pd.DataFrame, pd.Series

抛出

ValueError – 如果 y 是 None。

classmethod is_freq_valid(cls, freq: str)#

确定给定字符串是否代表此分解器有效的频率。

参数: freq (str) – 要验证的频率。有关选项，请参阅 pandas 文档：https://pandas.ac.cn/pandas-docs/stable/user_guide/timeseries.html#offset-aliases。
返回: 布尔值，表示频率是否有效。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

plot_decomposition(self, X: pandas.DataFrame, y: Union[pandas.Series, pandas.DataFrame], show: bool = False) → Union[tuple[matplotlib.pyplot.Figure, list], dict[str, tuple[matplotlib.pyplot.Figure]]]#

绘制目标信号的分解图。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series 或 pd.DataFrame) – 作为 Series 提供的目标变量数据用于单变量问题，或作为 DataFrame 提供的目标变量数据用于多变量问题。
show (bool) – 是否显示图。默认为 False。

返回

绘制了分解图的 Figure 和 Axes 对象。: plot on them
(多序列) dict[str, (matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes])]: 将序列 ID 映射到绘制了分解图的 Figure 和 Axes 对象的字典。: to the figure and axes

返回类型

(单序列) matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes]

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

set_period(self, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

根据目标的季节性设置组件季节性周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于阈值的任何值都被视为 0，不考虑用于周期确定。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

transform(self, X: pandas.DataFrame, y: pandas.Series = None) → tuple[pandas.DataFrame, pandas.Series][source]#

通过移除多项式趋势和移动平均季节性来转换目标数据。

应用拟合的多项式去趋势器到目标数据，移除加性多项式趋势。然后，利用 .fit() 函数中确定的第一个周期的季节性数据，推断要转换数据的季节性信号。此季节性信号也被假定为加性的并被移除。

参数

X (pd.DataFrame, 可选) – 有条件地用于构建 datetime 索引。
y (pd.Series) – 用于去趋势和去季节化的目标变量。

返回

输入特征将不做修改地返回。目标变量: 变量 y 被去趋势和去季节化。

返回类型

tuple of pd.DataFrame, pd.Series

抛出

ValueError – 如果目标数据没有 DatetimeIndex *并且*特征数据中没有 Datetime 特征

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.ReplaceNullableTypes(random_seed=0, **kwargs)[source]#

用于将具有新可空 dtype 的特征替换为 EvalML 中兼容 dtype 的转换器。

属性

超参数范围	None
修改特征	True
修改目标	{}
名称	替换可空类型转换器 (Replace Nullable Types Transformer)
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在数据和目标数据中，用新的 pandas 可空类型替换非可空类型。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过替换包含可空类型的列为适当的替换类型来转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)[source]#

在数据和目标数据中，用新的 pandas 可空类型替换非可空类型。

参数

X (pd.DataFrame, 可选) – 输入特征。
y (pd.Series) – 目标数据。

返回

设置了非可空类型的输入特征和目标数据。

返回类型

tuple of pd.DataFrame, pd.Series

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过替换包含可空类型的列为适当的替换类型来转换数据。

可空整数使用“float64”，可空布尔值使用“category”。

参数

X (pd.DataFrame) – 要转换的数据
y (pd.Series, 可选) – 要转换的目标数据

返回

转换后的 X, 转换后的 y (pd.Series)

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.RFClassifierRFESelector(step=0.2, min_features_to_select=1, cv=None, scoring=None, n_jobs=-1, n_estimators=10, max_depth=None, random_seed=0, **kwargs)[source]#

使用带有随机森林分类器的递归特征消除来选择相关特征。

参数

step (int, float) – 每次迭代要移除的特征数量。如果指定整数，表示要移除的特征数量。如果指定浮点数，表示每次迭代要移除的特征百分比。最后一次迭代可能会移除少于此数量的特征，以满足 min_features_to_select 约束。默认为 0.2。
min_features_to_select (int) – 要返回的最小特征数。默认为 1。
cv (int 或 None) – 用于交叉验证分割策略的折数。默认为 None，此时将使用 5 折。
scoring (str, callable 或 None) – 字符串或可调用评分器对象，用于指定评分方法。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
n_estimators (int) – 森林中的树的数量。默认为 10。
max_depth (int) – 基础学习器的最大树深度。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “step”: Real(0.05, 0.25)}
修改特征	True
修改目标	False
名称	带 RF 分类器的 RFE 选择器 (RFE Selector with RF Classifier)
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`获取名称`	获取所选特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取所选特征的名称。

返回: 所选特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或实现了 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.RFClassifierSelectFromModel(number_features=None, n_estimators=10, max_depth=None, percent_features=0.5, threshold='median', n_jobs=-1, random_seed=0, **kwargs)[source]#

使用随机森林分类器根据重要性权重选择排名靠前的特征。

参数

number_features (int) – 要选择的最大特征数。如果同时指定 percent_features 和 number_features，则取较大的特征数。默认为 None。
n_estimators (int) – 森林中的树的数量。默认为 10。
max_depth (int) – 基础学习器的最大树深度。默认为 None。
percent_features (float) – 要使用的特征百分比。如果同时指定 percent_features 和 number_features，则取较大的特征数。默认为 0.5。
threshold (string 或 float) – 用于特征选择的阈值。重要性大于或等于阈值的特征被保留，其他特征被丢弃。如果为“median”，则阈值是特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
修改特征	True
修改目标	False
名称	RF 分类器 Select From Model (RF Classifier Select From Model)
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`获取名称`	获取所选特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取所选特征的名称。

返回: 所选特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或实现了 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.RFRegressorRFESelector(step=0.2, min_features_to_select=1, cv=None, scoring=None, n_jobs=-1, n_estimators=10, max_depth=None, random_seed=0, **kwargs)[source]#

使用带有随机森林回归器的递归特征消除来选择相关特征。

参数

step (int, float) – 每次迭代要移除的特征数量。如果指定整数，表示要移除的特征数量。如果指定浮点数，表示每次迭代要移除的特征百分比。最后一次迭代可能会移除少于此数量的特征，以满足 min_features_to_select 约束。默认为 0.2。
min_features_to_select (int) – 要返回的最小特征数。默认为 1。
cv (int 或 None) – 用于交叉验证分割策略的折数。默认为 None，此时将使用 5 折。
scoring (str, callable 或 None) – 字符串或可调用评分器对象，用于指定评分方法。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
n_estimators (int) – 森林中的树的数量。默认为 10。
max_depth (int) – 基础学习器的最大树深度。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “step”: Real(0.05, 0.25)}
修改特征	True
修改目标	False
名称	带 RF 回归器的 RFE 选择器 (RFE Selector with RF Regressor)
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`获取名称`	获取所选特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取所选特征的名称。

返回: 所选特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或实现了 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.RFRegressorSelectFromModel(number_features=None, n_estimators=10, max_depth=None, percent_features=0.5, threshold='median', n_jobs=-1, random_seed=0, **kwargs)[source]#

使用随机森林回归器根据重要性权重选择排名靠前的特征。

参数

number_features (int) – 要选择的最大特征数。如果同时指定 percent_features 和 number_features，则取较大的特征数。默认为 0.5。（*注：这里默认值可能与定义不符，原文如此*）
n_estimators (int) – 森林中的树的数量。默认为 10。
max_depth (int) – 基础学习器的最大树深度。默认为 None。
percent_features (float) – 要使用的特征百分比。如果同时指定 percent_features 和 number_features，则取较大的特征数。默认为 0.5。
threshold (string 或 float) – 用于特征选择的阈值。重要性大于或等于阈值的特征被保留，其他特征被丢弃。如果为“median”，则阈值是特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
修改特征	True
修改目标	False
名称	RF 回归器 Select From Model (RF Regressor Select From Model)
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`获取名称`	获取所选特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取所选特征的名称。

返回: 所选特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将抛出 MethodPropertyNotFoundError 异常。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或实现了 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.SelectByType(column_types=None, exclude=False, random_seed=0, **kwargs)[source]#

根据输入数据中指定的 Woodwork 逻辑类型或语义标签选择列。

参数

column_types (string, ww.LogicalType, list(string), list(ww.LogicalType)) – Woodwork 类型或标签列表，用于确定选择或排除哪些列。
exclude (bool) – 如果为 True，则排除 column_types 而不是包含它们。默认为 False。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	按类型选择列转换器 (Select Columns By Type Transformer)
需要拟合	False
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	通过检查数据集中是否存在列名来拟合转换器。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过选择列来转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

通过检查数据集中是否存在列名来拟合转换器。

参数

X (pd.DataFrame) – 要检查的数据。
y (pd.Series, 忽略) – 目标。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过选择列来转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标。

返回

转换后的 X。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.SelectColumns(columns=None, random_seed=0, **kwargs)[source]#

选择输入数据中指定的列。

参数

columns (list(string)) – 列名列表，用于确定要选择哪些列。如果列不存在，则不会被选中。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	选择列转换器
需要拟合	False
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	通过检查数据集中是否存在列名来拟合转换器。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用已拟合的列选择器组件转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

通过检查数据集中是否存在列名来拟合转换器。

参数

X (pd.DataFrame) – 要检查的数据。
y (pd.Series, 可选) – 目标。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

使用已拟合的列选择器组件转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.SimpleImputer(impute_strategy='most_frequent', fill_value=None, random_seed=0, **kwargs)[source]#

根据指定的填充策略填充缺失数据。忽略自然语言列。

参数

impute_strategy (string) – 要使用的填充策略。有效值包括：针对数值数据，有“mean”、“median”、“most_frequent”、“constant”；针对对象数据类型，有“most_frequent”、“constant”。
fill_value (string) – 当 impute_strategy == “constant”时，fill_value 用于替换缺失数据。默认为 0（填充数值数据时）和“missing_value”（填充字符串或对象数据类型时）。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “impute_strategy”: [“mean”, “median”, “most_frequent”]}
修改特征	True
修改目标	False
名称	简单填充器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将填充器拟合到数据。“None”值在填充前转换为 np.nan，并被视为相同。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过填充缺失值来转换输入数据。'None' 和 np.nan 值被视为相同。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将填充器拟合到数据。“None”值在填充前转换为 np.nan，并被视为相同。

参数

X (pd.DataFrame 或 np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据

返回

self

抛出

ValueError – 如果 SimpleImputer 接收到包含布尔类型和类别类型数据的 DataFrame。

fit_transform(self, X, y=None)[source]#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据
y (pd.Series, 可选) – 目标数据。

返回

转换后的 X

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过填充缺失值来转换输入数据。‘None’ 和 np.nan 值被视为相同。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.StandardScaler(random_seed=0, **kwargs)[source]#

一个通过移除均值和缩放到单位方差来标准化输入特征的转换器。

参数: random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	标准缩放器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	在给定数据上拟合标准缩放器。
`拟合转换`	使用标准缩放器组件拟合和转换数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用已拟合的标准缩放器转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

在给定数据上拟合标准缩放器。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)[source]#

使用标准缩放器组件拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用已拟合的标准缩放器转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.STLDecomposer(time_index: str = None, series_id: str = None, degree: int = 1, period: int = None, periods: dict = None, seasonal_smoother: int = 7, random_seed: int = 0, **kwargs)[source]#

使用 STL 算法从时间序列中去除趋势和季节性。

https://statsmodels.cn/dev/generated/statsmodels.tsa.seasonal.STL.html

参数

time_index (str) – 指定 X 中提供 datetime 对象的列的名称。默认为 None。
series_id (str) – 指定 X 中提供多系列 series_id 对象的列的名称。默认为 None。
degree (int) – 目前未使用。STL 有 3 个“类似 degree”的值。目前无法设置。默认为 1。
period (int) – 时间序列数据中对应于一个周期性信号的条目数。例如，如果已知数据具有每周季节性信号，且数据是每日数据，则 period 应为 7。对于具有年度季节性信号的每日数据，period 应为 365。如果为 None，statsmodels 将根据频率推断周期。默认为 None。
seasonal_smoother (int) – 底层 STL 算法使用的季节性平滑器的长度。为兼容性起见，必须为奇数。如果提供了偶数，将使用下一个最高的奇数。默认为 7。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	None
无效频率 (invalid_frequencies)	[]
修改特征	False
修改目标	True
名称	STL 分解器
需要拟合	True
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`确定周期性 (determine_periodicity)`	使用自相关方法确定季节性信号最显著周期的函数。
`拟合`	拟合 STL 分解器并确定季节性信号。
`拟合转换`	从目标变量中移除拟合的趋势和季节性。
`获取趋势 DataFrame (get_trend_dataframe)`	返回一个包含 4 列的 DataFrame 列表：signal, trend, seasonality, residual。
`获取趋势预测区间`	计算趋势数据的预测区间。
`逆转换`	将拟合的趋势和季节性添加回目标变量。
`频率是否有效 (is_freq_valid)`	确定给定字符串是否代表此分解器有效的频率。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`绘制分解图 (plot_decomposition)`	绘制目标信号的分解图。
`保存`	将组件保存到文件路径。
`设置周期 (set_period)`	根据目标的季节性设置组件季节性周期的函数。
`转换`	通过移除 STL 趋势和季节性来转换目标数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

classmethod determine_periodicity(cls, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

使用自相关方法确定季节性信号最显著周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于阈值的任何值都被视为 0，不考虑用于周期确定。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

返回

时间序列数据中条目的整数数量，目标数据的季节性部分在此周期内重复。: 如果时间序列数据是日数据，则这是目标季节性信号重复所需的天数。注意：目标数据可以包含多个季节性信号。此函数仅返回更强的那个。例如，如果目标既有每周季节性又有年度季节性，函数可能返回“7”或“365”，具体取决于哪种季节性具有更强的自相关性。如果未检测到周期，则返回 None。

返回类型

int

fit(self, X: pandas.DataFrame, y: Union[pandas.Series, pandas.DataFrame] = None) → STLDecomposer[source]#

拟合 STL 分解器并确定季节性信号。

通过组件存储的参数实例化一个 statsmodels STL 分解对象并进行拟合。由于 statsmodels 对象不符合 sklearn API，因此在 __init__() 中不会在 _component_obj 中保存，并且每次调用 fit 时都会重新实例化。

为了模拟 sklearn API，拟合 STL 分解器时，会保存完整的季节性分量、季节性分量的单个周期样本、完整的趋势-周期分量以及残差。

y(t) = S(t) + T(t) + R(t)

参数

X (pd.DataFrame, 可选) – 有条件地用于构建 datetime 索引。
y (pd.Series 或 pd.DataFrame) – 要去趋势和季节性的目标变量。

返回

self

抛出

ValueError – 如果 y 是 None。
ValueError – 如果目标数据没有 DatetimeIndex *并且*特征数据中没有 Datetime 特征

fit_transform(self, X: pandas.DataFrame, y: pandas.Series = None) → tuple[pandas.DataFrame, pandas.Series]#

从目标变量中移除拟合的趋势和季节性。

参数

X (pd.DataFrame, optional) – 忽略。
y (pd.Series) – 用于去趋势和去季节化的目标变量。

返回

第一个元素是未经修改返回的输入特征。: 第二个元素是移除了拟合趋势的目标变量 y。

返回类型

tuple of pd.DataFrame, pd.Series

get_trend_dataframe(self, X, y)[source]#

返回一个包含 4 列的 DataFrame 列表：signal, trend, seasonality, residual。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series 或 pd.DataFrame) – 作为 Series 提供的目标变量数据用于单变量问题，或作为 DataFrame 提供的目标变量数据用于多变量问题。

返回

每个 DataFrame 包含列 “signal”, “trend”, “seasonality” 和 “residual”，: 后 3 列的值是目标数据的分解元素。“signal” 列仅仅是输入目标信号，但使用 datetime 索引重新索引以匹配输入特征。

(多系列) 字典列表：系列 id 映射到 pd.DataFrame 列表，每个 DataFrame 包含“signal”、“trend”、“seasonality”和“residual”列

返回类型

(单系列) pd.DataFrame 列表

抛出

TypeError – 如果 X 的索引中不包含时间序列数据。
ValueError – 如果 X 的时间序列索引没有推断的频率。
ValueError – 如果与去趋势器关联的预测器尚未拟合。
TypeError – 如果 y 未作为 pandas Series 或 DataFrame 提供。

get_trend_prediction_intervals(self, y, coverage=None)[source]#

计算趋势数据的预测区间。

参数

y (pd.Series 或 pd.DataFrame) – 目标数据。
coverage (list\[float\]) – 一个浮点数列表，值介于 0 和 1 之间，用于计算预测区间的上限和下限。

返回

预测区间，键格式为 {coverage}_lower 或 {coverage}_upper。(多系列) 字典的字典 pd.Series: 每个系列 id 映射到预测区间字典

返回类型

(单系列) pd.Series 字典

inverse_transform(self, y_t: Union[pandas.Series, pandas.DataFrame]) → Union[pandas.Series, pandas.DataFrame][source]#

将拟合的趋势和季节性添加回目标变量。

将 STL 趋势投影以覆盖整个请求的目标范围，然后加回信号。然后，将季节性投影到未来并加回信号。

参数: y_t (pd.Series 或 pd.DataFrame) – 目标变量。
返回: 目标变量 y，加回趋势和季节性。
返回类型: pd.Series 或 pd.DataFrame
抛出: ValueError – 如果 y 是 None。

classmethod is_freq_valid(cls, freq: str)#

确定给定字符串是否代表此分解器有效的频率。

参数: freq (str) – 要验证的频率。有关选项，请参阅 pandas 文档：https://pandas.ac.cn/pandas-docs/stable/user_guide/timeseries.html#offset-aliases。
返回: 布尔值，表示频率是否有效。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

绘制目标信号的分解图。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series 或 pd.DataFrame) – 作为 Series 提供的目标变量数据用于单变量问题，或作为 DataFrame 提供的目标变量数据用于多变量问题。
show (bool) – 是否显示图。默认为 False。

返回

绘制了分解图的 Figure 和 Axes 对象。: plot on them
(多序列) dict[str, (matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes])]: 将序列 ID 映射到绘制了分解图的 Figure 和 Axes 对象的字典。: to the figure and axes

返回类型

(单序列) matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes]

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

set_period(self, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

根据目标的季节性设置组件季节性周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于阈值的任何值都被视为 0，不考虑用于周期确定。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

transform(self, X: pandas.DataFrame, y: Union[pandas.Series, pandas.DataFrame] = None) → Union[tuple[pandas.DataFrame, pandas.Series], tuple[pandas.DataFrame, pandas.DataFrame]][source]#

通过移除 STL 趋势和季节性来转换目标数据。

使用 ARIMA 模型向前投影并移除累加趋势。然后，利用 .fit() 函数中确定的第一个周期的季节性数据来推断要转换的数据的季节性信号。此季节性信号也被假定为累加的并被移除。

参数

X (pd.DataFrame, 可选) – 有条件地用于构建 datetime 索引。
y (pd.Series 或 pd.DataFrame) – 要去趋势和季节性的目标变量。

返回

输入特征列表不作修改返回。目标: 变量 y 被去趋势和去季节化。
(多系列) pd.DataFrame, pd.DataFrame：输入特征列表不作修改返回。目标: 变量 y 被去趋势和去季节化。

返回类型

(单系列) pd.DataFrame, pd.Series

抛出

ValueError – 如果目标数据没有 DatetimeIndex *并且*特征数据中没有 Datetime 特征

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.TargetEncoder(cols=None, smoothing=1, handle_unknown='value', handle_missing='value', random_seed=0, **kwargs)[source]#

一个将分类特征编码为目标编码的转换器。

参数

cols (list) – 要编码的列。如果为 None，则编码所有字符串列，否则只编码提供的列。默认为 None
smoothing (float) – 要应用的平滑因子。该值越大，预期目标值对结果目标编码的影响越大。必须严格大于 0。默认为 1.0
handle_unknown (string) – 确定如何处理遇到的未知类别特征。选项包括“value”、“error”和“return_nan”。默认为“value”，该值替换为目标均值
handle_missing (string) – 确定如何处理在 fit 或 transform 期间遇到的缺失值。选项包括“value”、“error”和“return_nan”。默认为“value”，该值替换为目标均值
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	目标编码器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合目标编码器。
`拟合转换`	使用目标编码器拟合和转换数据。
`获取特征名称`	返回拟合后输入特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	使用已拟合的目标编码器转换数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

拟合目标编码器。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y)[source]#

使用目标编码器拟合和转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

get_feature_names(self)[source]#

返回拟合后输入特征的名称。

返回: 编码后的特征名称。
返回类型: np.array

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用已拟合的目标编码器转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.TargetImputer(impute_strategy='most_frequent', fill_value=None, random_seed=0, **kwargs)[source]#

根据指定填充策略填充缺失目标数据。

参数

impute_strategy (string) – 要使用的填充策略。对于数值数据，有效值包括“mean”、“median”、“most_frequent”、“constant”；对于对象数据类型，有效值包括“most_frequent”、“constant”。默认为“most_frequent”。
fill_value (string) – 当 impute_strategy == “constant”时，fill_value 用于替换缺失数据。默认为 None，该值在填充数值数据时使用 0，在填充字符串或对象数据类型时使用“missing_value”。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “impute_strategy”: [“mean”, “median”, “most_frequent”]}
修改特征	False
修改目标	True
名称	目标填充器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将填充器拟合到目标数据。在填充之前，'None' 值被转换为 np.nan 并被视为相同。
`拟合转换`	拟合并转换输入目标数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过填充缺失值来转换输入目标数据。'None' 和 np.nan 值被视为相同。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

在填充之前，‘None’ 值被转换为 np.nan 并被视为相同。

参数

X (pd.DataFrame 或 np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据。忽略。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

TypeError – 如果目标填充了所有 null 值。

fit_transform(self, X, y)[source]#

拟合并转换输入目标数据。

参数

X (pd.DataFrame) – 特征。忽略。
y (pd.Series) – 要填充的目标数据。

返回

原始 X，转换后的 y

返回类型

(pd.DataFrame, pd.Series)

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y)[source]#

通过填充缺失值来转换输入目标数据。‘None’ 和 np.nan 值被视为相同。

参数

X (pd.DataFrame) – 特征。忽略。
y (pd.Series) – 要填充的目标数据。

返回

原始 X，转换后的 y

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.TimeSeriesFeaturizer(time_index=None, max_delay=2, gap=0, forecast_horizon=1, conf_level=0.05, rolling_window_size=0.25, delay_features=True, delay_target=True, random_seed=0, **kwargs)[source]#

为时间序列问题延迟输入特征和目标变量的转换器。

此组件使用一种基于目标变量自相关值来确定从所有可能滞后集合中选择哪些滞后的算法。

该算法基于自相关函数的局部最大值表示对当前时间影响最大的滞后的思想。

该算法计算自相关值并找到在给定 conf_level 下显著的局部最大值，称为“峰值”。由于 \[0, 10] 范围内的滞后往往具有预测性但不是局部最大值，因此将峰值与 \[0, 10] 范围内显著的滞合取并集。最后，仅使用 \[0, max_delay] 范围内的选定滞后。

通过 conf_level 值参数化算法，使 AutoMLAlgorithm 能够调整选择的滞后集合，从而提高找到良好滞后集合的机会。

使用 conf_level 值为 1 会选择所有可能的滞后。

参数

time_index (字符串) – 包含用于对数据排序的日期时间信息的列名。忽略。
max_delay (int) – 每个特征的最大时间单位延迟数。默认为 2。
forecast_horizon (int) – 管道预期预测的时间周期数。
conf_level (float) – 介于 (0, 1] 之间的浮点数，用于确定从 \[1, max_delay] 集合中选择哪些滞后进行计算时使用的置信区间大小。始终会计算延迟 1。如果为 1，则选择 \[1, max_delay] 集合中所有可能的滞后，包括边界。
rolling_window_size (float) – 介于 (0, 1] 之间的浮点数，用于确定滚动特征的窗口大小。大小计算为 rolling_window_size * max_delay。
delay_features (bool) – 是否延迟输入特征。默认为 True。
delay_target (bool) – 是否延迟目标。默认为 True。
gap (int) – 特征收集时间与目标收集时间之间的时间单位数。例如，如果要预测下一个时间步的目标，则 gap=1。这仅在 gap=0 时需要，以确保目标变量的滞后从 1 开始。默认为 1。
random_seed (int) – 随机数生成器的种子。此转换器无论提供何种随机种子，其性能都相同。

属性

df_colname_prefix	{}_delay_{}
超参数范围	Real(0.001, 1.0), “rolling_window_size”: Real(0.001, 1.0)}:type: {“conf_level”
修改特征	True
修改目标	False
名称	时间序列特征化器
需要拟合	True
target_colname_prefix	target_delay_{}
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 DelayFeatureTransformer。
`拟合转换`	拟合组件并转换输入数据。
`加载`	从文件路径加载组件。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	计算 X 和 y 的延迟值和滚动均值。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 DelayFeatureTransformer。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果 self.time_index 为 None

fit_transform(self, X, y=None)[source]#

拟合组件并转换输入数据。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 或 None) – 目标。

返回

转换后的 X。

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

计算 X 和 y 的延迟值和滚动均值。

所选滞后由目标变量的自相关函数确定。有关如何选择滞后的更多信息，请参见类文档字符串。如果 y 为 None，则选择所有可能的滞后。

如果 y 不为 None，它还将计算目标变量的延迟值。

如果 y 是数值型，X 中所有数值特征和 y 的滚动均值也会返回。

参数

X (pd.DataFrame 或 None) – 要转换的数据。当仅使用目标变量时，预期为 None。
y (pd.Series, 或 None) – 目标。

返回

转换后的 X。不返回原始特征。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.TimeSeriesImputer(categorical_impute_strategy='forwards_fill', numeric_impute_strategy='interpolate', target_impute_strategy='forwards_fill', random_seed=0, **kwargs)[source]#

根据指定的时间序列特定填充策略填充缺失数据。

此转换器应在 TimeSeriesRegularizer 之后使用，以填充添加到 X 和 y（如果传入）中的缺失值。

参数

categorical_impute_strategy (string) – 要用于字符串、对象、布尔、类别数据类型的填充策略。有效值包括“backwards_fill”和“forwards_fill”。默认为“forwards_fill”。
numeric_impute_strategy (string) – 要用于数值列的填充策略。有效值包括“backwards_fill”、“forwards_fill”和“interpolate”。默认为“interpolate”。
target_impute_strategy (string) – 要用于目标列的填充策略。有效值包括“backwards_fill”、“forwards_fill”和“interpolate”。默认为“forwards_fill”。
random_seed (整数) – 随机数生成器的种子。默认为 0。

抛出

ValueError – 如果 categorical_impute_strategy、numeric_impute_strategy 或 target_impute_strategy 不是有效值之一。

属性

超参数范围	{ “categorical_impute_strategy”: [“backwards_fill”, “forwards_fill”], “numeric_impute_strategy”: [“backwards_fill”, “forwards_fill”, “interpolate”], “target_impute_strategy”: [“backwards_fill”, “forwards_fill”, “interpolate”],}
修改特征	True
修改目标	True
名称	时间序列填充器
仅训练	True

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将填充器拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过使用指定的时间序列特定策略填充缺失值来转换数据 X。在填充之前，'None' 值被转换为 np.nan 并被视为相同。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将填充器拟合到数据。

‘None’ 值在填充之前被转换为 np.nan 并被视为相同。如果列的开头或结尾处缺少值，则该值将分别使用向后填充或向前填充进行填充。

参数

X (pd.DataFrame, np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过使用指定的时间序列特定策略填充缺失值来转换数据 X。‘None’ 值在填充之前被转换为 np.nan 并被视为相同。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 可选，要转换的目标数据。

返回

转换后的 X 和 y

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.TimeSeriesRegularizer(time_index=None, frequency_payload=None, window_length=4, threshold=0.4, random_seed=0, **kwargs)[source]#

对不规则间隔的日期时间列进行正则化的转换器。

如果将 X 传入 fit/transform 方法，将检查 time_index 列是否存在可推断的偏移频率。如果 time_index 列完全可推断，则此 Transformer 将不做任何操作，并返回原始的 X 和 y。

如果 X 没有完全可推断的频率，但可以估计，则会基于 time_index 的估计频率重新格式化 X 和 y。在传入的原始 X 和 y 中： - 将添加缺失的日期时间值，并且 X 和 y 中对应的列将被设置为 None。 - 重复的日期时间值将被丢弃。 - 多余的日期时间值将被丢弃。 - 如果可以确定重复或多余的值未对齐，则会将其重新定位以取代缺失值。

此 Transformer 应在 TimeSeriesImputer 之前使用，以便对添加到 X 和 y（如果传入）中的缺失值进行填充。

如果在多序列数据集上使用，则专门作用于未堆叠的数据集。

参数

time_index (字符串) – 包含用于对数据排序的日期时间信息的列名，必需参数。默认为 None。
frequency_payload (元组) – 从 Woodwork 的 infer_frequency 函数返回的 payload，其中 debug 为 True。默认为 None。
window_length (整数) – 用于推断滚动窗口的大小，以确定不可推断频率的普遍程度。
5. (值越低，此组件对识别众多故障日期时间值越敏感。默认为) –
threshold (浮点数) – 能够推断出频率的窗口的最小百分比。值越低，此组件对识别众多故障日期时间值越敏感。
0.8. (默认为) –
random_seed (int) – 随机数生成器的种子。此转换器无论提供何种随机种子，其性能都相同。
0. (默认为) –

抛出

ValueError – 如果 frequency_payload 参数未传入元组

属性

超参数范围	{}
修改特征	True
修改目标	True
名称	时间序列正则化器
仅训练	True

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	拟合 TimeSeriesRegularizer。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	将数据框和目标数据正则化为可推断的偏移频率。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 TimeSeriesRegularizer。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果 self.time_index 为 None，如果 X 和 y 长度不同，如果 X 中的 time_index 没有可估计的偏移频率
TypeError – 如果 time_index 列不是 Datetime 类型
KeyError – 如果 time_index 列不存在

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

将数据框和目标数据正则化为可推断的偏移频率。

根据可推断的偏移频率创建一个“干净”的 X 和 y（如果传入了 y），并将与原始 X 和 y 匹配的日期时间值填充到干净的 X 和 y 中。识别为未对齐的日期时间值将被移动到其适当位置。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

具有可推断 time_index 偏移频率的数据。

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.Transformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

一个可能或可能不需要拟合来转换数据的组件。这些组件在估计器之前使用。

要实现一个新的 Transformer，请定义一个您自己的类，该类是 Transformer 的子类，并包含一个名称以及在 automl 搜索（超参数）期间要调整的任何参数的可接受范围列表。定义一个 __init__ 方法来设置任何必要的状态和对象。确保您的 __init__ 只使用标准的关键字参数，并调用 super().__init__() 并传入一个 parameters 字典。如果适用，您也可以重写此类中的 fit、transform、fit_transform 和其他方法。

要查看一些示例，请查看任何 Transformer 组件的定义。

参数

parameters (dict) – 组件的参数字典。默认为 None。
component_obj (对象) – 在组件实现中有用的第三方对象。默认为 None。
random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

修改特征	True
修改目标	False
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`名称`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)[source]#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

property name(cls)#: 返回此组件的字符串名称。

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

abstract transform(self, X, y=None)[source]#

转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.Undersampler(sampling_ratio=0.25, sampling_ratio_dict=None, min_samples=100, min_percentage=0.1, random_seed=0, **kwargs)[source]#

初始化一个欠采样转换器，以对数据集中的多数类进行下采样。

此组件仅在训练期间运行，不在预测期间运行。

参数

sampling_ratio (浮点数) – 被接受为“平衡”的最小少数类与多数类比例。例如，1:4 的比例表示为 0.25，而 1:1 的比例表示为 1.0。必须介于 0 和 1 之间（包含）。默认为 0.25。
sampling_ratio_dict (dict) – 一个字典，指定每个目标值的期望平衡比例。例如，在二元分类中，如果类别 1 是少数类，我们可以指定：sampling_ratio_dict={0: 0.5, 1: 1}，这意味着我们将对类别 0 进行欠采样，使其样本数量是类别 1 的两倍（少数类:多数类比例 = 0.5），并且不对类别 1 进行采样。如果提供了此参数，将覆盖 sampling_ratio。默认为 None。
min_samples (整数) – 采样前或采样后，任何类必须拥有的最小样本数。如果必须对某个类进行欠采样，则不会使其少于此值。为了确定严重不平衡，少数类出现的次数必须少于此值，并且类比例必须低于 min_percentage。必须大于 0。默认为 100。
min_percentage (浮点数) – 我们容忍的最小类占总数据集的最小百分比，前提是它高于 min_samples。如果未达到 min_percentage 和 min_samples，则将其视为严重不平衡，我们将不会重新采样数据。必须介于 0 和 0.5 之间（包含）。默认为 0.1。
random_seed (int) – 用于随机采样的种子。默认为 0。

抛出

ValueError – 如果 sampling_ratio 不在 (0, 1] 范围内。
ValueError – 如果 min_sample 不大于 0。
ValueError – 如果 min_percentage 不在 0 和 0.5 之间（包含）。

属性

超参数范围	{}
修改特征	True
修改目标	True
名称	Undersampler
仅训练	True

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将采样器拟合到数据。
`fit_resample`	此采样器的重采样技术。
`拟合转换`	使用采样器组件拟合并转换数据。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	通过采样数据来转换输入数据。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)#

将采样器拟合到数据。

参数

X (pd.DataFrame) – 输入特征。
y (pd.Series) – 目标变量。

返回

self

抛出

ValueError – 如果 y 是 None。

fit_resample(self, X, y)[source]#

此采样器的重采样技术。

参数

X (pd.DataFrame) – 用于拟合和重新采样的训练数据。
y (pd.Series) – 用于拟合和重新采样的训练数据目标。

返回

用于训练数据要保留的索引。

返回类型

列表

fit_transform(self, X, y)#

使用采样器组件拟合并转换数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

转换后的数据。

返回类型

(pd.DataFrame, pd.Series)

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过采样数据来转换输入数据。

参数

X (pd.DataFrame) – 训练特征。
y (pd.Series) – 目标变量。

返回

转换后的特征和目标变量。

返回类型

pd.DataFrame, pd.Series

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.transformers.URLFeaturizer(random_seed=0, **kwargs)[source]#

可以自动从 URL 中提取特征的转换器。

参数: random_seed (整数) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
修改特征	True
修改目标	False
名称	URL 特征化器
仅训练	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`保存`	将组件保存到文件路径。
`转换`	转换数据 X。
`更新参数`	更新组件的参数字典。

clone(self)#

构造一个具有相同参数和随机状态的新组件。

返回: 此组件的一个新实例，具有相同的参数和随机状态。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (布尔值, 可选) – 是否打印组件名称
return_dict (布尔值, 可选) – 是否以 {“name”: name, “parameters”: parameters} 格式将描述作为字典返回

返回

如果 return_dict 为 True，则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的输入训练数据。
y (pd.Series, 可选) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 的 component_obj。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 要拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (字符串) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (字符串) – 保存文件的位置。
pickle_protocol (整数) – pickle 数据流格式。

transform(self, X, y=None)#

转换数据 X。

参数

X (pd.DataFrame) – 要转换的数据。
y (pd.Series, 可选) – 目标数据。

返回

转换后的 X

返回类型

pd.DataFrame

抛出

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 的 component_obj。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (布尔值, 可选) – 如果为 True，将设置 _is_fitted 为 False。

转换器#

子包#

子模块#

包内容#

类摘要#

目录#