管道#

EvalML 管道。

子模块#

包内容#

类摘要#

`ARIMARegressor`	自回归积分移动平均模型。三个参数 (p, d, q) 分别是 AR 阶数、差分阶数和 MA 阶数。更多信息请参见：https://statsmodels.cn/devel/generated/statsmodels.tsa.arima.model.ARIMA.html。
`BinaryClassificationPipeline`	所有二元分类管道的管道子类。
`CatBoostClassifier`	CatBoost 分类器，一种使用决策树梯度提升的分类器。CatBoost 是一个开源库，原生支持类别特征。
`CatBoostRegressor`	CatBoost 回归器，一种使用决策树梯度提升的回归器。CatBoost 是一个开源库，原生支持类别特征。
`ClassificationPipeline`	所有分类管道的管道子类。
`ComponentGraph`	管道的组件图，表示为有向无环图 (DAG)。
`DecisionTreeClassifier`	决策树分类器。
`DecisionTreeRegressor`	决策树回归器。
`DFSTransformer`	Featuretools DFS 组件，用于为输入特征生成特征。
`DropNaNRowsTransformer`	丢弃包含 NaN 值的行的转换器。
`ElasticNetClassifier`	Elastic Net 分类器。使用带有 elasticnet 惩罚项的逻辑回归作为基础估计器。
`ElasticNetRegressor`	Elastic Net 回归器。
`Estimator`	拟合给定数据并进行预测的组件。
`ExponentialSmoothingRegressor`	Holt-Winters 指数平滑预测器。
`ExtraTreesClassifier`	Extra Trees 分类器。
`ExtraTreesRegressor`	Extra Trees 回归器。
`FeatureSelector`	根据重要性权重选择最重要的特征。
`Imputer`	根据指定的填充策略填充缺失数据。
`KNeighborsClassifier`	K 近邻分类器。
`LightGBMClassifier`	LightGBM 分类器。
`LightGBMRegressor`	LightGBM 回归器。
`LinearRegressor`	线性回归器。
`LogisticRegressionClassifier`	逻辑回归分类器。
`MulticlassClassificationPipeline`	所有多元分类管道的管道子类。
`MultiseriesRegressionPipeline`	用于多序列时间序列回归问题的管道基类。
`OneHotEncoder`	将类别特征编码为独热数值数组的转换器。
`OrdinalEncoder`	将有序特征编码为表示类别相对顺序的有序整数数组的转换器。
`PerColumnImputer`	根据每列指定的填充策略填充缺失数据。
`PipelineBase`	机器学习管道。
`ProphetRegressor`	Prophet 是一种基于加性模型的预测时间序列数据的过程，其中非线性趋势通过年度、每周和每日季节性以及假日效应进行拟合。它最适用于具有强季节性效应和多个季节历史数据的时间序列。Prophet 对缺失数据和趋势变化具有鲁棒性，并且通常能很好地处理异常值。
`RandomForestClassifier`	随机森林分类器。
`RandomForestRegressor`	随机森林回归器。
`RegressionPipeline`	所有回归管道的管道子类。
`RFClassifierSelectFromModel`	使用随机森林分类器根据重要性权重选择最重要的特征。
`RFRegressorSelectFromModel`	使用随机森林回归器根据重要性权重选择最重要的特征。
`SimpleImputer`	根据指定的填充策略填充缺失数据。自然语言列将被忽略。
`StackedEnsembleBase`	堆叠集成基类。
`StackedEnsembleClassifier`	堆叠集成分类器。
`StackedEnsembleRegressor`	堆叠集成回归器。
`StandardScaler`	通过去除均值并缩放到单位方差来标准化输入特征的转换器。
`SVMClassifier`	支持向量机分类器。
`SVMRegressor`	支持向量机回归器。
`TargetEncoder`	将类别特征编码为目标编码的转换器。
`TimeSeriesBinaryClassificationPipeline`	用于时间序列二元分类问题的管道基类。
`TimeSeriesClassificationPipeline`	用于时间序列分类问题的管道基类。
`TimeSeriesFeaturizer`	为时间序列问题延迟输入特征和目标变量的转换器。
`TimeSeriesImputer`	根据指定的时间序列特定填充策略填充缺失数据。
`TimeSeriesMulticlassClassificationPipeline`	用于时间序列多元分类问题的管道基类。
`TimeSeriesRegressionPipeline`	用于时间序列回归问题的管道基类。
`TimeSeriesRegularizer`	正则化间隔不一致的日期时间列的转换器。
`Transformer`	可能需要或不需要拟合来转换数据的组件。这些组件在估计器之前使用。
`VARMAXRegressor`	带有外生回归器的向量自回归移动平均模型。两个参数 (p, q) 是 AR 阶数和 MA 阶数。更多信息请参见：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。
`XGBoostClassifier`	XGBoost 分类器。
`XGBoostRegressor`	XGBoost 回归器。

目录#

class evalml.pipelines.ARIMARegressor(time_index: Optional[Hashable] = None, trend: Optional[str] = None, start_p: int = 2, d: int = 0, start_q: int = 2, max_p: int = 5, max_d: int = 2, max_q: int = 5, seasonal: bool = True, sp: int =1, n_jobs: int = -1, random_seed: Union[int, float] = 0, maxiter: int = 10, use_covariates: bool = True, **kwargs)[source]#

自回归积分移动平均模型。三个参数 (p, d, q) 分别是 AR 阶数、差分阶数和 MA 阶数。更多信息请参见：https://statsmodels.cn/devel/generated/statsmodels.tsa.arima.model.ARIMA.html。

目前 ARIMARegressor 不支持通过 conda 安装。建议通过 PyPI 安装。

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
trend (str) – 控制确定性趋势。选项包括 [‘n’, ‘c’, ‘t’, ‘ct’]，其中 ‘c’ 是常数项，‘t’ 表示线性趋势，‘ct’ 表示两者都有。定义多项式时也可以是可迭代对象，例如 [1, 1, 0, 1]。
start_p (int) – 最小自回归阶数。默认为 2。
d (int) – 最小差分阶数。默认为 0。
start_q (int) – 最小移动平均阶数。默认为 2。
max_p (int) – 最大自回归阶数。默认为 5。
max_d (int) – 最大差分阶数。默认为 2。
max_q (int) – 最大移动平均阶数。默认为 5。
seasonal (boolean) – 是否为 ARIMA 拟合季节性模型。默认为 True。
sp (int or str) – 季节性差分的周期，特别是每个季节的周期数。如果设置为“detect”，该模型将自动检测此参数（假定时间序列是标准频率），如果无法检测，将回退到 1（无季节性）。默认为 1。
n_jobs (int or None) – 描述管道使用的并行级别的非负整数。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “start_p”: Integer(1, 3), “d”: Integer(0, 2), “start_q”: Integer(1, 3), “max_p”: Integer(3, 10), “max_d”: Integer(2, 5), “max_q”: Integer(3, 10), “seasonal”: [True, False],}
max_cols	7
max_rows	1000
model_family	ModelFamily.ARIMA
modifies_features	True
modifies_target	False
name	ARIMA 回归器
supported_problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回长度为 1 的 0 数组，因为 ARIMA 回归器未定义特征重要性。
`拟合`	将 ARIMA 回归器拟合到数据。
`获取预测区间`	使用已拟合的 ARIMARegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 ARIMA 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → numpy.ndarray#: 返回长度为 1 的 0 数组，因为 ARIMA 回归器未定义特征重要性。

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

将 ARIMA 回归器拟合到数据。

参数

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

返回

self

抛出

ValueError – 如果未传入 y。

get_prediction_intervals(self, X: pandas.DataFrame, y: pandas.Series = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series][source]#

使用已拟合的 ARIMARegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。可选。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
predictions (pd.Series) – 不用于 ARIMA 回归器。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

使用已拟合的 ARIMA 回归器进行预测。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。

返回

预测值。

返回类型

pd.Series

抛出

ValueError – 如果 X 在 fit 中传入但未在 predict 中传入。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.BinaryClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

所有二元分类管道的管道子类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中的组件重复时，重复组件的名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将变为 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = BinaryClassificationPipeline(component_graph=["Simple Imputer", "Logistic Regression Classifier"],
...                                         parameters={"Logistic Regression Classifier": {"penalty": "elasticnet",
...                                                                                        "solver": "liblinear"}},
...                                         custom_name="My Binary Pipeline")
...
>>> assert pipeline.custom_name == "My Binary Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Logistic Regression Classifier'}

管道参数将从每个组件的默认参数中选择，除非像上面那样传入了特定参数。

>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'most_frequent', 'fill_value': None},
...     'Logistic Regression Classifier': {'penalty': 'elasticnet',
...                                        'C': 1.0,
...                                        'n_jobs': -1,
...                                        'multi_class': 'auto',
...                                        'solver': 'liblinear'}}

属性

problem_type

ProblemTypes.BINARY

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`优化阈值`	根据要使用的目标优化管道阈值。仅用于阈值可调的二元问题。
`参数`	此管道的参数字典。
`预测`	使用选定的特征进行预测。
`预测概率`	生成标签的概率估计。假定索引 1 处的列代表正标签情况。
`保存`	将管道保存到文件路径。
`评分`	评估模型在目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`阈值`	用于进行预测的阈值。默认为 None。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

获取管道的类别名称。在管道拟合之前将返回 None。

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

此管道的新实例，具有相同的组件、参数和随机种子。: 从字符串列表或目标类创建目标实例。

static create_objectives(objectives)#: 管道的自定义名称。

从字符串列表或目标类创建目标实例。

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

describe(self, return_dict=False)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

property feature_importance(self)#

构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

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

ValueError – 如果 y 中的唯一类别数量不适合管道类型。

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

y (pd.Series) – 目标数据，长度为 [n_samples]。

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

name (str) – 组件名称。

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

get_hyperparameter_ranges(self, custom_hyperparameters)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graphviz.Digraph

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

x_edges 指定特征数据从哪个组件传递。y_edges 指定目标数据从哪个组件传递。这可用于在各种可视化工具中构建图形。模板：{“Nodes”: {“component_name”: {“Name”: class_name, “Parameters”: parameters_attributes}, …}}, “x_edges”: [[from_component_name, to_component_name], [from_component_name, to_component_name], …], “y_edges”: [[from_component_name, to_component_name], [from_component_name, to_component_name], …]}

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

显示特征及其对应重要性的条形图。

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

实现 inverse_transform 的组件有 PolynomialDecomposer、LogTransformer、LabelEncoder (待定)。

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

static load(file_path: Union[str, io.BytesIO])#: 返回此管道的模型族。

file_path (str|BytesIO) – 加载文件路径或 BytesIO 对象。: 管道名称。

PipelineBase 对象

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property name(self)#

根据要使用的目标优化管道阈值。仅用于阈值可调的二元问题。

参数

管道名称。
new(self, parameters, random_seed=0)#
构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
此管道的新实例，具有相同的组件。

抛出

optimize_threshold(self, X, y, y_pred_proba, objective)#

X (pd.DataFrame) – 输入特征。

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

y_pred_proba (pd.Series) – 管道输出的目标预测概率。

使用选定的特征进行预测。

objective (ObjectiveBase) – 用于确定阈值的目标。必须具有可调阈值。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
ValueError – 如果目标不可优化。
property parameters(self)#
所有组件参数的字典。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

注意：我们首先将 y 转换为整数，以处理在计算预测时可能返回的布尔值，否则如果我们原始目标是整数，我们将无法进行转换。

生成标签的概率估计。假定索引 1 处的列代表正标签情况。

参数

objective (Object or string) – 用于进行预测的目标。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

估计的标签。

返回类型

pd.Series

predict_proba(self, X, X_train=None, y_train=None)[source]#

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]

评估模型在目标上的性能。

参数

X_train (pd.DataFrame or np.ndarray or None) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series or None) – 训练标签。忽略。仅用于时间序列。
概率估计
property parameters(self)#
所有组件参数的字典。

返回

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

返回类型

dict

score(self, X, y, objectives, X_train=None, y_train=None)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

objectives (list) – 要评分的目标列表: 用于进行预测的阈值。默认为 None。

目标评分的有序字典。

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

描述管道结构的字符串。

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
用于进行预测的阈值。默认为 None。
transform(self, X, y=None)#
X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None)#

CatBoost 分类器，一种使用决策树梯度提升的分类器。CatBoost 是一个开源库，原生支持类别特征。

X (pd.DataFrame) – 要转换的管道输入数据。

参数

y (pd.Series or None) – 与 X 对应的目标。可选。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。仅用于时间序列。
y_train (pd.Series or None) – 训练标签。仅用于时间序列。
新的转换后特征。
class evalml.pipelines.CatBoostClassifier(n_estimators=10, eta=0.03, max_depth=6, bootstrap_type=None, silent=True, allow_writing_files=False, random_seed=0, n_jobs=-1, **kwargs)[source]#
更多信息，请访问 https://catboost.ai/
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	eta (float) – 学习率。默认为 0.03。
model_family	max_depth (int) – 基本学习器的最大树深度。默认为 6。
modifies_features	True
modifies_target	False
name	bootstrap_type (string) – 定义对象权重采样的方法。可用方法包括 ‘Bayesian’、‘Bernoulli’、‘MVS’。默认为 None。
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	allow_writing_files (boolean) – 训练时是否允许写入快照文件。默认为 False。
`拟合`	n_jobs (int or None) – 并行运行的作业数。-1 使用所有进程。默认为 -1。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	ModelFamily.CATBOOST
`预测概率`	CatBoost 分类器
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]

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

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

已拟合的 CatBoost 分类器的特征重要性。

返回此组件的默认参数。

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

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

将 CatBoost 分类器组件拟合到数据。

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

使用已拟合的回归器查找预测区间。: allow_writing_files (boolean) – 训练时是否允许写入快照文件。默认为 False。

使用已拟合的 CatBoost 分类器进行预测。

n_jobs (int or None) – 并行运行的作业数。-1 使用所有进程。默认为 -1。

参数

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

返回

self

使用已拟合的 CatBoost 分类器生成预测概率。

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

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

从文件路径加载组件。

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

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

此函数获取已拟合估计器的预测结果，并使用窗口大小为 5 计算所有预测结果的滚动标准差。下限和上限预测通过取每个界限的下尾概率的百分点（分位数）函数乘以滚动标准差来确定。: 返回用于初始化组件的参数。

y (pd.Series) – 目标数据。忽略。

ModelFamily.CATBOOST

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series

predictions (pd.Series) – 可选的预测列表。如果为 None，将使用 X 生成预测。

CatBoost 分类器

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: MethodPropertyNotFoundError – 如果估计器不支持时间序列回归作为问题类型。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

static load(file_path)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

needs_fitting(self)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.CatBoostRegressor(n_estimators=10, eta=0.03, max_depth=6, bootstrap_type=None, silent=False, allow_writing_files=False, random_seed=0, n_jobs=-1, **kwargs)[source]#

CatBoost 回归器，一种使用决策树梯度提升的回归器。CatBoost 是一个开源库，原生支持类别特征。

X (pd.DataFrame) – 要转换的管道输入数据。

参数

y (pd.Series or None) – 与 X 对应的目标。可选。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。仅用于时间序列。
y_train (pd.Series or None) – 训练标签。仅用于时间序列。
新的转换后特征。
class evalml.pipelines.CatBoostClassifier(n_estimators=10, eta=0.03, max_depth=6, bootstrap_type=None, silent=True, allow_writing_files=False, random_seed=0, n_jobs=-1, **kwargs)[source]#
更多信息，请访问 https://catboost.ai/
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	eta (float) – 学习率。默认为 0.03。
model_family	max_depth (int) – 基本学习器的最大树深度。默认为 6。
modifies_features	True
modifies_target	False
name	CatBoost 回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合 CatBoost 回归器的特征重要性。
`拟合`	将 CatBoost 回归器组件拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 CatBoost 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 已拟合 CatBoost 回归器的特征重要性。

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

将 CatBoost 回归器组件拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X)[source]#

使用已拟合的 CatBoost 回归器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

所有分类管道的管道子类。

参数

component_graph (list or dict) – 组件列表中组件的顺序。列表中接受字符串或 ComponentBase 子类。请注意，当列表中指定重复组件时，重复的组件名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 将具有名称 ["Imputer", "One Hot Encoder", "Imputer_2", "Logistic Regression Classifier"]
parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

problem_type

无

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将管道保存到文件路径。
`评分`	评估模型在目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

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

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)[source]#

使用选定的特征进行预测。

objective (ObjectiveBase) – 用于确定阈值的目标。必须具有可调阈值。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
ValueError – 如果目标不可优化。
property parameters(self)#
所有组件参数的字典。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

predict_proba(self, X, X_train=None, y_train=None)[source]#

为标签生成概率估计。

参数

objective (Object or string) – 用于进行预测的目标。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

估计的标签。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

ValueError – 如果最终组件不是估计器。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)[source]#

评估模型在目标上的性能。

参数

X_train (pd.DataFrame or np.ndarray or None) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series or None) – 训练标签。忽略。仅用于时间序列。
概率估计
property parameters(self)#
所有组件参数的字典。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
用于进行预测的阈值。默认为 None。
transform(self, X, y=None)#
X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.ComponentGraph(component_dict=None, cached_data=None, random_seed=0)[source]#

管道的组件图，表示为有向无环图 (DAG)。

参数

component_dict (dict) – 一个字典，用于指定应创建组件图的组件及组件之间的边。默认为 None。
cached_data (dict) – 一个嵌套缓存数据的字典。如果哈希值和组件在此缓存中，我们将跳过这些组件的拟合过程。预期的格式为 {哈希值1: {组件名称: 已训练组件, ...}, 哈希值2: {...}, ...}。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> component_dict = {'Imputer': ['Imputer', 'X', 'y'],
...                   'Logistic Regression': ['Logistic Regression Classifier', 'Imputer.x', 'y']}
>>> component_graph = ComponentGraph(component_dict)
>>> assert component_graph.compute_order == ['Imputer', 'Logistic Regression']
...
...
>>> component_dict = {'Imputer': ['Imputer', 'X', 'y'],
...                   'OHE': ['One Hot Encoder', 'Imputer.x', 'y'],
...                   'estimator_1': ['Random Forest Classifier', 'OHE.x', 'y'],
...                   'estimator_2': ['Decision Tree Classifier', 'OHE.x', 'y'],
...                   'final': ['Logistic Regression Classifier', 'estimator_1.x', 'estimator_2.x', 'y']}
>>> component_graph = ComponentGraph(component_dict)

组件图中每个组件的默认参数。

>>> assert component_graph.default_parameters == {
...     'Imputer': {'categorical_impute_strategy': 'most_frequent',
...                 'numeric_impute_strategy': 'mean',
...                 'boolean_impute_strategy': 'most_frequent',
...                 'categorical_fill_value': None,
...                 'numeric_fill_value': None,
...                 'boolean_fill_value': None},
...     'One Hot Encoder': {'top_n': 10,
...                         'features_to_encode': None,
...                         'categories': None,
...                         'drop': 'if_binary',
...                         'handle_unknown': 'ignore',
...                         'handle_missing': 'error'},
...     'Random Forest Classifier': {'n_estimators': 100,
...                                  'max_depth': 6,
...                                  'n_jobs': -1},
...     'Decision Tree Classifier': {'criterion': 'gini',
...                                  'max_features': 'sqrt',
...                                  'max_depth': 6,
...                                  'min_samples_split': 2,
...                                  'min_weight_fraction_leaf': 0.0},
...     'Logistic Regression Classifier': {'penalty': 'l2',
...                                        'C': 1.0,
...                                        'n_jobs': -1,
...                                        'multi_class': 'auto',
...                                        'solver': 'lbfgs'}}

方法

`compute_order`	组件将被计算或调用的顺序。
`默认参数`	此流水线的默认参数字典。
`描述`	输出组件图详细信息，包括组件参数。
`拟合`	拟合图中的每个组件。
`fit_and_transform_all_but_final`	拟合并转换除最后一个（通常是估计器）之外的所有组件。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`generate_order`	重新生成图的拓扑排序顺序。
`获取组件`	从图中检索单个组件对象。
`get_component_input_logical_types`	获取传递给给定组件的逻辑类型。
`get_estimators`	获取此图中所有估计器组件的列表。
`get_inputs`	检索给定组件的所有输入。
`get_last_component`	检索图中最后计算的组件，通常是最终的估计器。
`图`	生成表示组件图的图像。
`has_dfs`	此组件图是否包含 DFSTransformer。
`instantiate`	使用给定参数实例化图中所有未实例化的组件。如果组件已实例化，但参数字典中包含该组件的参数，则会引发错误。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`last_component_input_logical_types`	获取传递给流水线中最后一个组件的逻辑类型。
`预测`	使用选定的特征进行预测。
`转换`	使用组件图转换输入。
`转换除最终组件外的所有组件`	转换除最后一个之外的所有组件，并从任意数量的父级收集数据，以获取应馈送给最终组件的所有信息。

property compute_order(self)#: 组件将被计算或调用的顺序。

property default_parameters(self)#

此流水线的默认参数字典。

返回: 所有组件默认参数的字典。
返回类型: dict

describe(self, return_dict=False)[source]#

输出组件图详细信息，包括组件参数。

参数: return_dict (bool) – 如果为 True，则返回关于组件图信息的字典。默认为 False。
返回: 如果 return_dict 为 True，则为所有组件参数的字典，否则为 None。
返回类型: dict
抛出: ValueError – 如果组件图未实例化。

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

拟合图中的每个组件。

参数

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

返回

self

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

拟合并转换除最后一个（通常是估计器）之外的所有组件。

参数

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

返回

转换后的特征和目标。

返回类型

Tuple (pd.DataFrame, pd.Series)

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

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

classmethod generate_order(cls, component_dict)[source]#: 重新生成图的拓扑排序顺序。

get_component(self, component_name)[source]#

从图中检索单个组件对象。

参数: component_name (str) – 要检索的组件名称
返回: ComponentBase 对象
抛出: ValueError – 如果组件不在图中。

get_component_input_logical_types(self, component_name)[source]#

获取传递给给定组件的逻辑类型。

参数

component_name (str) – 图中的组件名称

返回

Dict - 将特征名称映射到逻辑类型实例。

抛出

ValueError – 如果组件不在图中。
ValueError – 如果组件图尚未拟合

get_estimators(self)[source]#

获取此图中所有估计器组件的列表。

返回: 图中所有估计器对象。
返回类型: list
抛出: ValueError – 如果组件图尚未实例化。

get_inputs(self, component_name)[source]#

检索给定组件的所有输入。

参数: component_name (str) – 要查找的组件名称。
返回: 供组件使用的输入列表。
返回类型: list[str]
抛出: ValueError – 如果组件不在图中。

get_last_component(self)[source]#

检索图中最后计算的组件，通常是最终的估计器。

返回: ComponentBase 对象
抛出: ValueError – 如果组件图没有边。

graph(self, name=None, graph_format=None)[source]#

生成表示组件图的图像。

参数

name (str) – 图的名称。默认为 None。
graph_format (str) – 保存图的文件格式。默认为 None。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。

property has_dfs(self)#: 此组件图是否包含 DFSTransformer。

instantiate(self, parameters=None)[source]#

使用给定参数实例化图中所有未实例化的组件。如果组件已实例化，但参数字典中包含该组件的参数，则会引发错误。

参数: parameters (dict) – 字典，键为组件名称，值为该组件参数的字典。空字典 {} 或 None 表示使用组件参数的所有默认值。如果组件图中的某个组件已实例化，则它将不会使用此字典中定义的任何参数。默认为 None。
返回: self
抛出: ValueError – 如果组件图已实例化，或组件在实例化时出错。

inverse_transform(self, y)[source]#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: y – (pd.Series): 最终组件特征。
返回: 应用逆变换后的目标。
返回类型: pd.Series

property last_component_input_logical_types(self)#

获取传递给流水线中最后一个组件的逻辑类型。

返回

Dict - 将特征名称映射到逻辑类型实例。

抛出

ValueError – 如果组件不在图中。
ValueError – 如果组件图尚未拟合

predict(self, X)[source]#

使用选定的特征进行预测。

参数: TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
返回: 预测值。
返回类型: pd.Series
抛出: ValueError – 如果最终组件不是估计器。

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

使用组件图转换输入。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

ValueError – 如果最终组件不是 Transformer。

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

转换除最后一个之外的所有组件，并从任意数量的父级收集数据，以获取应馈送给最终组件的所有信息。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series, optional) – 长度为 [n_samples] 的目标训练数据。默认为 None。

返回

转换后的值。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.DecisionTreeClassifier(criterion='gini', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)[source]#

决策树分类器。

参数

criterion ({"gini", "entropy"}) – 衡量分裂质量的函数。支持的标准包括用于基尼不纯度的“gini”和用于信息增益的“entropy”。默认为“gini”。
max_features (int, float or {"sqrt", "log2"}) –
查找最佳分裂时要考虑的特征数量
- 如果是 int，则在每次分裂时考虑 max_features 个特征。
- 如果是 float，则 max_features 是一个分数，每次分裂时考虑 int(max_features * n_features) 个特征。
- 如果是“sqrt”，则 max_features=sqrt(n_features)。
- 如果是“log2”，则 max_features=log2(n_features)。
- 如果是 None，则 max_features = n_features。
搜索分裂不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
分裂内部节点所需的最小样本数
- 如果是 int，则将 min_samples_split 视为最小数量。
- 如果是 float，则 min_samples_split 是一个分数，ceil(min_samples_split * n_samples) 是每次分裂的最小样本数。
默认为 2。
min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “criterion”: [“gini”, “entropy”], “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
model_family	ModelFamily.DECISION_TREE
modifies_features	True
modifies_target	False
name	决策树分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.DecisionTreeRegressor(criterion='squared_error', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)[source]#

决策树回归器。

参数

criterion ({"squared_error", "friedman_mse", "absolute_error", "poisson"}) –
衡量分裂质量的函数。支持的标准包括
- “squared_error” 表示均方误差，它等于方差减少作为特征选择标准，并使用每个叶节点的均值最小化 L2 损失
- “friedman_mse”，它使用均方误差和 Friedman 用于潜在分裂的改进分数
- “absolute_error” 表示平均绝对误差，它使用每个叶节点的中位数最小化 L1 损失，
- “poisson”，它使用 Poisson 偏差的减少来查找分裂。
max_features (int, float or {"sqrt", "log2"}) –
查找最佳分裂时要考虑的特征数量
- 如果是 int，则在每次分裂时考虑 max_features 个特征。
- 如果是 float，则 max_features 是一个分数，每次分裂时考虑 int(max_features * n_features) 个特征。
- 如果是“sqrt”，则 max_features=sqrt(n_features)。
- 如果是“log2”，则 max_features=log2(n_features)。
- 如果是 None，则 max_features = n_features。
搜索分裂不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
分裂内部节点所需的最小样本数
- 如果是 int，则将 min_samples_split 视为最小数量。
- 如果是 float，则 min_samples_split 是一个分数，ceil(min_samples_split * n_samples) 是每次分裂的最小样本数。
默认为 2。
min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “criterion”: [“squared_error”, “friedman_mse”, “absolute_error”], “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
model_family	ModelFamily.DECISION_TREE
modifies_features	True
modifies_target	False
name	决策树回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

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

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

参数

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

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	DFS Transformer
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`contains_pre_existing_features`	确定 DFS Transformer 中的特征是否与流水线输入特征匹配。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	拟合 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)[source]#

确定 DFS Transformer 中的特征是否与流水线输入特征匹配。

参数

dfs_features (Optional[List[FeatureBase]]) – DFS Transformer 输出的特征列表。
input_feature_names (List[str]) – 输入到 DFS Transformer 的特征名称列表。
target (Optional[str]) – 我们尝试预测其值的目标。这用于在 DFS Transformer 参数的特征列表中存在目标列时知道要忽略哪个列。

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

拟合 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。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

特征矩阵

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.DropNaNRowsTransformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

丢弃包含 NaN 值的行的转换器。

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

属性

超参数范围	{}
modifies_features	True
modifies_target	True
name	丢弃 NaN 行转换器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [n_samples] 的目标训练数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

已删除包含 NaN 行的数据。

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ElasticNetClassifier(penalty='elasticnet', C=1.0, l1_ratio=0.15, multi_class='auto', solver='saga', n_jobs=-1, random_seed=0, **kwargs)[source]#

Elastic Net 分类器。使用带有 elasticnet 惩罚项的逻辑回归作为基础估计器。

参数

penalty ({"l1", "l2", "elasticnet", "none"}) – 惩罚中使用的范数。默认为“elasticnet”。
C (float) – 正则化强度的倒数。必须是正浮点数。默认为 1.0。
l1_ratio (float) – 混合参数，取值范围为 0 <= l1_ratio <= 1。仅在 penalty='elasticnet' 时使用。设置 l1_ratio=0 相当于使用 penalty='l2'，而设置 l1_ratio=1 相当于使用 penalty='l1'。对于 0 < l1_ratio < 1，惩罚是 L1 和 L2 的组合。默认为 0.15。
multi_class ({"auto", "ovr", "multinomial"}) – 如果选择的选项是“ovr”，则为每个标签拟合一个二元问题。对于“multinomial”，最小化的损失是拟合整个概率分布的多项式损失，即使数据是二元的。“multinomial”在 solver=“liblinear” 时不可用。“auto”在数据是二元或 solver=“liblinear” 时选择“ovr”，否则选择“multinomial”。默认为“auto”。
solver ({"newton-cg", "lbfgs", "liblinear", "sag", "saga"}) –
用于优化问题的算法。对于小型数据集，“liblinear”是一个不错的选择，而“sag”和“saga”对于大型数据集更快。对于多类别问题，只有“newton-cg”、“sag”、“saga”和“lbfgs”处理多项式损失；“liblinear”仅限于一对余方案。
- “newton-cg”、“lbfgs”、“sag”和“saga”处理 L2 或无惩罚
- “liblinear”和“saga”也处理 L1 惩罚
- “saga”也支持“elasticnet”惩罚
- “liblinear”不支持设置 penalty=’none’
默认为“saga”。
n_jobs (int) – 用于运行 xgboost 的并行线程数。请注意，创建线程竞争会显著降低算法速度。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “C”: Real(0.01, 10), “l1_ratio”: Real(0, 1)}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	弹性网络分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	拟合的弹性网络分类器的特征重要性。
`拟合`	将弹性网络分类器组件拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 拟合的弹性网络分类器的特征重要性。

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

将弹性网络分类器组件拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ElasticNetRegressor(alpha=0.0001, l1_ratio=0.15, max_iter=1000, random_seed=0, **kwargs)[source]#

Elastic Net 回归器。

参数

alpha (float) – 乘以惩罚项的常数。默认为 0.0001。
l1_ratio (float) – 混合参数，取值范围为 0 <= l1_ratio <= 1。仅在 penalty='elasticnet' 时使用。设置 l1_ratio=0 相当于使用 penalty='l2'，而设置 l1_ratio=1 相当于使用 penalty='l1'。对于 0 < l1_ratio < 1，惩罚是 L1 和 L2 的组合。默认为 0.15。
max_iter (int) – 最大迭代次数。默认为 1000。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “alpha”: Real(0, 1), “l1_ratio”: Real(0, 1),}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	弹性网络回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	拟合的弹性网络回归器的特征重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 拟合的弹性网络回归器的特征重要性。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.Estimator(parameters: dict = None, component_obj: Type[evalml.pipelines.components.ComponentBase] = None, random_seed: Union[int, float] = 0, **kwargs)[source]#

拟合给定数据并进行预测的组件。

要实现新的 Estimator，请定义您自己的类，该类是 Estimator 的子类，包括一个名称以及在 automl 搜索期间要调整的任何参数（超参数）的可接受范围列表。定义一个 __init__ 方法来设置任何必要的状态和对象。确保您的 __init__ 只使用标准关键字参数，并使用参数字典调用 super().__init__()。如果合适，您还可以重写此类中的 fit、transform、fit_transform 和其他方法。

要查看一些示例，请查看任何 Estimator 组件子类的定义。

参数

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

属性

model_family	ModelFamily.NONE
modifies_features	True
modifies_target	False
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`model_family`	ModelFamily.NONE
`name`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`supported_problem_types`	此估计器支持的问题类型。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series][source]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

property model_family(cls)#: 返回此组件的 ModelFamily。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series[source]#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series[source]#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

property supported_problem_types(cls)#: 此估计器支持的问题类型。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ExponentialSmoothingRegressor(trend: Optional[str] = None, damped_trend: bool = False, seasonal: Optional[str] = None, sp: int = 2, n_jobs: int = -1, random_seed: Union[int, float] = 0, **kwargs)[source]#

Holt-Winters 指数平滑预测器。

目前，ExponentialSmoothingRegressor 不支持通过 conda 安装。建议通过 PyPI 安装。

参数

trend (str) – 趋势分量的类型。默认为 None。
damped_trend (bool) – 趋势分量是否应被阻尼。默认为 False。
seasonal (str) – 季节分量的类型。取值之一为 {“additive”, None}。如果目标数据中没有
0 (none of the target data is) – 0，也可以是乘性的，
None. (but AutoMLSearch wiill not tune for this. Defaults to) – （但 AutoMLSearch 不会对此进行调优。默认为 None。）
sp (int) – 要考虑的季节周期数。默认为 2。
n_jobs (int or None) – 描述管道使用的并行级别的非负整数。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “trend”: [None, “additive”], “damped_trend”: [True, False], “seasonal”: [None, “additive”], “sp”: Integer(2, 8),}
model_family	ModelFamily.EXPONENTIAL_SMOOTHING
modifies_features	True
modifies_target	False
name	指数平滑回归器
supported_problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回长度为 1 的全零数组，因为 Exponential Smoothing 回归器未定义 feature_importance。
`拟合`	将指数平滑回归器拟合到数据。
`获取预测区间`	使用拟合的 ExponentialSmoothingRegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#: 返回长度为 1 的全零数组，因为 Exponential Smoothing 回归器未定义 feature_importance。

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

将指数平滑回归器拟合到数据。

参数

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

返回

self

抛出

ValueError – 如果未传入 y。

使用拟合的 ExponentialSmoothingRegressor 查找预测区间。

通过使用遵循指定状态空间模型的时间序列模拟来计算预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。可选。
coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上下界。
predictions (pd.Series) – 不用于 Exponential Smoothing 回归器。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

使用拟合的指数平滑回归器进行预测。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的数据。除了用于设置预测范围外，其余被忽略。
y (pd.Series) – 目标数据。

返回

预测值。

返回类型

pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ExtraTreesClassifier(n_estimators=100, max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, n_jobs=-1, random_seed=0, **kwargs)[source]#

Extra Trees 分类器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_features (int, float or {"sqrt", "log2"}) –
查找最佳分裂时要考虑的特征数量
- 如果是 int，则在每次分裂时考虑 max_features 个特征。
- 如果是 float，则 max_features 是一个分数，每次分裂时考虑 int(max_features * n_features) 个特征。
- 如果是“sqrt”，则 max_features=sqrt(n_features)。
- 如果是“log2”，则 max_features=log2(n_features)。
- 如果是 None，则 max_features = n_features。
搜索分裂不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
分裂内部节点所需的最小样本数
- 如果是 int，则将 min_samples_split 视为最小数量。
- 如果是 float，则 min_samples_split 是一个分数，ceil(min_samples_split * n_samples) 是每次分裂的最小样本数。
2. (Defaults to) – 2。（默认为）
min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “n_estimators”: Integer(10, 1000), “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
model_family	ModelFamily.EXTRA_TREES
modifies_features	True
modifies_target	False
name	Extra Trees 分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.ExtraTreesRegressor(n_estimators: int = 100, max_features: str = 'sqrt', max_depth: int = 6, min_samples_split: int = 2, min_weight_fraction_leaf: float = 0.0, n_jobs: int = -1, random_seed: Union[int, float] = 0, **kwargs)[source]#

Extra Trees 回归器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_features (int, float or {"sqrt", "log2"}) –
查找最佳分裂时要考虑的特征数量
- 如果是 int，则在每次分裂时考虑 max_features 个特征。
- 如果是 float，则 max_features 是一个分数，每次分裂时考虑 int(max_features * n_features) 个特征。
- 如果是“sqrt”，则 max_features=sqrt(n_features)。
- 如果是“log2”，则 max_features=log2(n_features)。
- 如果是 None，则 max_features = n_features。
搜索分裂不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
分裂内部节点所需的最小样本数
- 如果是 int，则将 min_samples_split 视为最小数量。
- 如果是 float，则 min_samples_split 是一个分数，ceil(min_samples_split * n_samples) 是每次分裂的最小样本数。
2. (Defaults to) – 2。（默认为）
min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “n_estimators”: Integer(10, 1000), “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
model_family	ModelFamily.EXTRA_TREES
modifies_features	True
modifies_target	False
name	Extra Trees 回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	使用拟合的 ExtraTreesRegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

使用拟合的 ExtraTreesRegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。可选。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.FeatureSelector(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

根据重要性权重选择最重要的特征。

参数

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

属性

modifies_features	True
modifies_target	False
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`加载`	从文件路径加载组件。
`name`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

抛出

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

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

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

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

get_names(self)[source]#

获取选定特征的名称。

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.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)[source]#

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

参数

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

属性

超参数范围	{ “categorical_impute_strategy”: [“most_frequent”], “numeric_impute_strategy”: [“mean”, “median”, “most_frequent”, “knn”], “boolean_impute_strategy”: [“most_frequent”]}
modifies_features	True
modifies_target	False
name	Imputer
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.KNeighborsClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, random_seed=0, **kwargs)[source]#

K 近邻分类器。

参数

n_neighbors (int) – 默认使用的邻居数量。默认为 5。
weights ({‘uniform’, ‘distance’} or callable) –
预测中使用的权重函数。可以是：
- ‘uniform’ : 统一权重。邻域中的所有点权重相等。
- ‘distance’ : 按距离的倒数对点进行加权。在这种情况下，查询点附近更近的邻居比远的邻居影响更大。
- [callable] : 用户定义的函数，接受一个距离数组，并返回一个具有相同形状的数组，其中包含权重。
默认为“uniform”。
algorithm ({‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}) –
用于计算最近邻的算法。
- ‘ball_tree’ 将使用 BallTree
- ‘kd_tree’ 将使用 KDTree
- ‘brute’ 将使用暴力搜索。
‘auto’ 将尝试根据传递给 fit 方法的值来决定最合适的算法。默认为“auto”。注意：对稀疏输入进行拟合将覆盖此参数的设置，使用暴力搜索。
leaf_size (int) – 传递给 BallTree 或 KDTree 的叶子大小。这会影响构建和查询的速度，以及存储树所需的内存。最优值取决于问题的性质。默认为 30。
p (int) – Minkowski 度量的幂参数。当 p = 1 时，这等价于使用 manhattan_distance (l1)，当 p = 2 时等价于使用 euclidean_distance (l2)。对于任意的 p，使用 minkowski_distance (l_p)。默认为 2。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “n_neighbors”: Integer(2, 12), “weights”: [“uniform”, “distance”], “algorithm”: [“auto”, “ball_tree”, “kd_tree”, “brute”], “leaf_size”: Integer(10, 30), “p”: Integer(1, 5),}
model_family	ModelFamily.K_NEIGHBORS
modifies_features	True
modifies_target	False
name	KNN分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回一个与输入特征数量匹配的由 0 组成的数组，因为 KNN 分类器未定义 feature_importance。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 返回一个与输入特征数量匹配的由 0 组成的数组，因为 KNN 分类器未定义 feature_importance。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series[source]#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series[source]#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.LightGBMClassifier(boosting_type='gbdt', learning_rate=0.1, n_estimators=100, max_depth=0, num_leaves=31, min_child_samples=20, bagging_fraction=0.9, bagging_freq=0, n_jobs=-1, random_seed=0, **kwargs)[source]#

LightGBM 分类器。

参数

boosting_type (string) – 要使用的提升类型。默认为“gbdt”。- ‘gbdt’ 使用传统梯度提升决策树 - “dart” 使用 Dropouts meet Multiple Additive Regression Trees - “goss” 使用 Gradient-based One-Side Sampling - “rf” 使用随机森林。
learning_rate (float) – 提升学习率。默认为 0.1。
n_estimators (int) – 要拟合的提升树数量。默认为 100。
max_depth (int) – 基础学习器的最大树深度，<=0 表示无限制。默认为 0。
num_leaves (int) – 基础学习器的最大树叶子数量。默认为 31。
min_child_samples (int) – 子（叶子）中所需的最少数据样本数量。默认为 20。
bagging_fraction (float) – 如果此值小于 1.0，LightGBM 将在每次迭代（树）中随机选择一个特征子集而无需重新采样。例如，如果设置为 0.8，LightGBM 将在训练每棵树之前选择 80% 的特征。这可用于加快训练速度并处理过拟合。默认为 0.9。
bagging_freq (int) – bagging 的频率。0 表示禁用 bagging。k 表示每 k 次迭代执行 bagging。每第 k 次迭代，LightGBM 将随机选择 bagging_fraction * 100% 的数据用于接下来的 k 次迭代。默认为 0。
n_jobs (int or None) – 并行运行的线程数量。-1 表示使用所有线程。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “learning_rate”: Real(0.000001, 1), “boosting_type”: [“gbdt”, “dart”, “goss”, “rf”], “n_estimators”: Integer(10, 100), “max_depth”: Integer(0, 10), “num_leaves”: Integer(2, 100), “min_child_samples”: Integer(1, 100), “bagging_fraction”: Real(0.000001, 1), “bagging_freq”: Integer(0, 1),}
model_family	ModelFamily.LIGHTGBM
modifies_features	True
modifies_target	False
name	LightGBM分类器
SEED_MAX	SEED_BOUNDS.max_bound
SEED_MIN	0
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将 LightGBM 分类器组件拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 LightGBM 分类器进行预测。
`预测概率`	使用已拟合的 LightGBM 分类器计算预测概率。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将 LightGBM 分类器组件拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X)[source]#

使用已拟合的 LightGBM 分类器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

predict_proba(self, X)[source]#

使用已拟合的 LightGBM 分类器计算预测概率。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: MethodPropertyNotFoundError – 如果估计器不支持时间序列回归作为问题类型。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.LightGBMRegressor(boosting_type='gbdt', learning_rate=0.1, n_estimators=20, max_depth=0, num_leaves=31, min_child_samples=20, bagging_fraction=0.9, bagging_freq=0, n_jobs=-1, random_seed=0, **kwargs)[source]#

LightGBM 回归器。

参数

boosting_type (string) – 要使用的提升类型。默认为“gbdt”。- ‘gbdt’ 使用传统梯度提升决策树 - “dart” 使用 Dropouts meet Multiple Additive Regression Trees - “goss” 使用 Gradient-based One-Side Sampling - “rf” 使用随机森林。
learning_rate (float) – 提升学习率。默认为 0.1。
n_estimators (int) – 要拟合的提升树数量。默认为 100。
max_depth (int) – 基础学习器的最大树深度，<=0 表示无限制。默认为 0。
num_leaves (int) – 基础学习器的最大树叶子数量。默认为 31。
min_child_samples (int) – 子（叶子）中所需的最少数据样本数量。默认为 20。
bagging_fraction (float) – 如果此值小于 1.0，LightGBM 将在每次迭代（树）中随机选择一个特征子集而无需重新采样。例如，如果设置为 0.8，LightGBM 将在训练每棵树之前选择 80% 的特征。这可用于加快训练速度并处理过拟合。默认为 0.9。
bagging_freq (int) – bagging 的频率。0 表示禁用 bagging。k 表示每 k 次迭代执行 bagging。每第 k 次迭代，LightGBM 将随机选择 bagging_fraction * 100% 的数据用于接下来的 k 次迭代。默认为 0。
n_jobs (int or None) – 并行运行的线程数量。-1 表示使用所有线程。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “learning_rate”: Real(0.000001, 1), “boosting_type”: [“gbdt”, “dart”, “goss”, “rf”], “n_estimators”: Integer(10, 100), “max_depth”: Integer(0, 10), “num_leaves”: Integer(2, 100), “min_child_samples”: Integer(1, 100), “bagging_fraction”: Real(0.000001, 1), “bagging_freq”: Integer(0, 1),}
model_family	ModelFamily.LIGHTGBM
modifies_features	True
modifies_target	False
name	LightGBM回归器
SEED_MAX	SEED_BOUNDS.max_bound
SEED_MIN	0
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将 LightGBM 回归器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 LightGBM 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将 LightGBM 回归器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X)[source]#

使用已拟合的 LightGBM 回归器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.LinearRegressor(fit_intercept=True, n_jobs=-1, random_seed=0, **kwargs)[source]#

线性回归器。

参数

fit_intercept (boolean) – 是否计算该模型的截距。如果设置为 False，则计算中不使用截距（即预期数据已中心化）。默认为 True。
n_jobs (int or None) – 并行运行的作业数量。-1 表示使用所有线程。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “fit_intercept”: [True, False],}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	线性回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合线性回归器的特征重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 已拟合线性回归器的特征重要性。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.LogisticRegressionClassifier(penalty='l2', C=1.0, multi_class='auto', solver='lbfgs', n_jobs=-1, random_seed=0, **kwargs)[source]#

逻辑回归分类器。

参数

penalty ({"l1", "l2", "elasticnet", "none"}) – 惩罚中使用的范数。默认为“l2”。
C (float) – 正则化强度的倒数。必须是正浮点数。默认为 1.0。
multi_class ({"auto", "ovr", "multinomial"}) – 如果选择的选项是“ovr”，则为每个标签拟合一个二元问题。对于“multinomial”，最小化的损失是拟合整个概率分布的多项式损失，即使数据是二元的。“multinomial”在 solver=“liblinear” 时不可用。“auto”在数据是二元或 solver=“liblinear” 时选择“ovr”，否则选择“multinomial”。默认为“auto”。
solver ({"newton-cg", "lbfgs", "liblinear", "sag", "saga"}) –
用于优化问题的算法。对于小型数据集，“liblinear”是一个不错的选择，而“sag”和“saga”对于大型数据集更快。对于多类别问题，只有“newton-cg”、“sag”、“saga”和“lbfgs”处理多项式损失；“liblinear”仅限于一对余方案。
- “newton-cg”、“lbfgs”、“sag”和“saga”处理 L2 或无惩罚
- “liblinear”和“saga”也处理 L1 惩罚
- “saga”也支持“elasticnet”惩罚
- “liblinear”不支持设置 penalty=’none’
默认为“lbfgs”。
n_jobs (int) – 用于运行 xgboost 的并行线程数。请注意，创建线程竞争会显著降低算法速度。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “penalty”: [“l2”], “C”: Real(0.01, 10),}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	逻辑回归分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合逻辑回归分类器的特征重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 已拟合逻辑回归分类器的特征重要性。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.MulticlassClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

所有多元分类管道的管道子类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中的组件重复时，重复组件的名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将变为 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = MulticlassClassificationPipeline(component_graph=["Simple Imputer", "Logistic Regression Classifier"],
...                                             parameters={"Logistic Regression Classifier": {"penalty": "elasticnet",
...                                                                                            "solver": "liblinear"}},
...                                             custom_name="My Multiclass Pipeline")
...
>>> assert pipeline.custom_name == "My Multiclass Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Logistic Regression Classifier'}

管道参数将从每个组件的默认参数中选择，除非像上面那样传入了特定参数。

>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'most_frequent', 'fill_value': None},
...     'Logistic Regression Classifier': {'penalty': 'elasticnet',
...                                        'C': 1.0,
...                                        'n_jobs': -1,
...                                        'multi_class': 'auto',
...                                        'solver': 'liblinear'}}

属性

problem_type

ProblemTypes.MULTICLASS

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将管道保存到文件路径。
`评分`	评估模型在目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

fit(self, X, y)#

构建分类模型。对于字符串和类别目标，类别通过 sorted(set(y)) 排序，然后映射到 0 到 n_classes-1 之间的值。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

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

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

使用选定的特征进行预测。

objective (ObjectiveBase) – 用于确定阈值的目标。必须具有可调阈值。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
ValueError – 如果目标不可优化。
property parameters(self)#
所有组件参数的字典。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

predict_proba(self, X, X_train=None, y_train=None)#

为标签生成概率估计。

参数

objective (Object or string) – 用于进行预测的目标。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

估计的标签。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

ValueError – 如果最终组件不是估计器。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)#

评估模型在目标上的性能。

参数

X_train (pd.DataFrame or np.ndarray or None) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series or None) – 训练标签。忽略。仅用于时间序列。
概率估计
property parameters(self)#
所有组件参数的字典。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
用于进行预测的阈值。默认为 None。
transform(self, X, y=None)#
X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.MultiseriesRegressionPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

用于多序列时间序列回归问题的管道基类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。
parameters (dict) – 以组件名称为键、以该组件参数字典为值的字典。空字典 {} 表示使用组件参数的所有默认值。管道级别的参数（如 time_index、gap 和 max_delay）必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

NO_PREDS_PI_ESTIMATORS	ProblemTypes.TIME_SERIES_REGRESSION
problem_type	ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测给定未来日期所需的日期。
`dates_needed_for_prediction_range`	返回预测给定未来日期所需的日期。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	拟合多序列时间序列管道。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`get_forecast_period`	根据 X 中的最新数据点生成所有可能的预测时间点。
`get_forecast_predictions`	根据 X 的最后周期生成所有可能的预测预测。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	对目标未知未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

属性 custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测给定未来日期所需的日期。

参数: date (pd.Timestamp) – 预测未来日期。
返回: 预测给定日期所需日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测给定未来日期所需的日期。

参数

start_date (pd.Timestamp) – 预测未来范围的开始日期。
end_date (pd.Timestamp) – 预测未来范围的结束日期。

返回

预测给定日期所需日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

属性 feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

fit(self, X, y)[来源]#

拟合多序列时间序列管道。

参数

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

返回

self

抛出

ValueError – 如果目标不是数字。

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_forecast_period(self, X)[来源]#

根据 X 中的最新数据点生成所有可能的预测时间点。

对于多序列情况，每个时间戳都会针对 X 的 series_id 列中的每个唯一值进行复制。输入数据必须堆叠以正确生成唯一的周期。

参数: X (pd.DataFrame, np.ndarray) – 管道训练时使用的堆叠数据，形状为 [n_samples_train * n_series_ids, n_features]。
抛出: ValueError – 如果管道未训练。
返回: 包含一个列的 DataFrame，该列包含从 gap 到 forecast_horizon + gap 的每个唯一 series_id 值的日期时间周期。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

get_forecast_predictions(self, X, y)#

根据 X 的最后周期生成所有可能的预测预测。

参数

X (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]。
y (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

从 gap 周期到 forecast_horizon + gap 周期的预测。

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

get_prediction_intervals(self, X, y=None, X_train=None, y_train=None, coverage=None)#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

某些估计器（Extra Trees Estimator、XGBoost Estimator、Prophet Estimator、ARIMA 和 Exponential Smoothing estimator）采用不同的方法来计算预测区间。有关详细信息，请参阅这些估计器的文档。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

静态 load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

属性 model_family(self)#: 返回此管道的模型族。

属性 name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

属性 parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知未来数据进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最终组件不是 Estimator。

返回

预测。

predict_in_sample(self, X, y, X_train, y_train, objective=None, calculating_residuals=False, include_series_id=False)[来源]#

对目标已知未来数据进行预测，例如交叉验证。

参数

X (pd.DataFrame or np.ndarray) – 未来数据，形状为 [n_samples, n_features]
y (pd.Series, np.ndarray) – 未来目标，形状为 [n_samples]
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]
objective (ObjectiveBase, str, None) – 用于对预测概率进行阈值处理的目标，可选。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。
include_series_id (bool) – 如果为 true，则在预测结果中包含序列 ID 值

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

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

返回类型

dict

属性 summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
y (pd.Series) – 与管道目标对应的目标。
X_train (pd.DataFrame) – 用于根据过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于根据过去的观测生成特征的训练目标。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

类 evalml.pipelines.OneHotEncoder(top_n=10, features_to_encode=None, categories=None, drop='if_binary', handle_unknown='ignore', handle_missing='error', random_seed=0, **kwargs)[来源]#

将类别特征编码为独热数值数组的转换器。

参数

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 (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	独热编码器
training_only	False

方法

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

categories(self, feature_name)[来源]#

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

参数: 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

ValueError – 如果编码列失败。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

get_feature_names(self)[来源]#

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

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

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

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

静态 load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

对输入数据进行独热编码。

参数

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

返回

转换后的数据，其中每个分类特征都已使用独热编码编码为数字列。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

类 evalml.pipelines.OrdinalEncoder(features_to_encode=None, categories=None, handle_unknown='error', unknown_value=None, encoded_missing_value=None, random_seed=0, **kwargs)[来源]#

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

参数

features_to_encode (list[str]) – 要编码的列列表。所有其他列将保持不变。如果为 None，则所有适当的列都将被编码。默认为 None。列的顺序无关紧要。
categories (dict[str, list[str]]) – 一个字典，将列名映射到在 fit 和 transform 时传入的 DataFrame 中的类别。为列指定的类别顺序无关紧要。数据中发现的任何不在 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 期间看到的缺失（空）值的值。默认为 np.nan。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	顺序编码器
training_only	False

方法

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

categories(self, feature_name)[来源]#

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

参数: 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [n_samples] 的目标训练数据。

返回

self

抛出

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

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

get_feature_names(self)[来源]#

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

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

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

静态 load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

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

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

类 evalml.pipelines.PerColumnImputer(impute_strategies=None, random_seed=0, **kwargs)[来源]#

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

参数

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

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	按列填充器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

参数

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

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

静态 load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

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

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

类 evalml.pipelines.PipelineBase(component_graph, parameters=None, custom_name=None, random_seed=0)[来源]#

机器学习管道。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当在列表中指定重复组件时，重复组件的名称将使用组件在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将是 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]。
parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

problem_type

无

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	构建模型。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	使用选定的特征进行预测。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)[来源]#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

clone(self)[来源]#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

静态 create_objectives(objectives)[来源]#: 从字符串列表或目标类创建目标实例。

属性 custom_name(self)#: 管道的自定义名称。

describe(self, return_dict=False)[来源]#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

属性 feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抽象 fit(self, X, y)[来源]#

构建模型。

参数

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

返回

self

fit_transform(self, X, y)[来源]#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)[来源]#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)[来源]#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)[来源]#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)[来源]#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)[来源]#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)[来源]#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

静态 load(file_path: Union[str, io.BytesIO])[来源]#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

属性 model_family(self)#: 返回此管道的模型族。

属性 name(self)#: 管道名称。

new(self, parameters, random_seed=0)[来源]#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

属性 parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)[来源]#

使用选定的特征进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

预测值。

返回类型

pd.Series

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)[来源]#

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

抽象 score(self, X, y, objectives, X_train=None, y_train=None)[来源]#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series, np.ndarray) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

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

返回类型

dict

属性 summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

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

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None)[来源]#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
用于进行预测的阈值。默认为 None。
transform(self, X, y=None)#
X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

类 evalml.pipelines.ProphetRegressor(time_index: Optional[Hashable] = None, changepoint_prior_scale: float = 0.05, seasonality_prior_scale: int = 10, holidays_prior_scale: int = 10, seasonality_mode: str = 'additive', stan_backend: str = 'CMDSTANPY', interval_width: float = 0.95, random_seed: Union[int, float] = 0, **kwargs)[来源]#

Prophet 是一种基于加性模型的预测时间序列数据的过程，其中非线性趋势通过年度、每周和每日季节性以及假日效应进行拟合。它最适用于具有强季节性效应和多个季节历史数据的时间序列。Prophet 对缺失数据和趋势变化具有鲁棒性，并且通常能很好地处理异常值。

更多信息请访问：https://fbdocs.cn/prophet/

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
changepoint_prior_scale (float) – 确定拟合变化率时稀疏先验的强度。增加此值会增加趋势的灵活性。默认为 0.05。
seasonality_prior_scale (int) – 类似于 changepoint_prior_scale。调整季节性模型拟合数据的程度。默认为 10。
holidays_prior_scale (int) – 类似于 changepoint_prior_scale。调整节假日拟合数据的程度。默认为 10。
seasonality_mode (str) – 确定此组件如何拟合季节性。选项包括“additive”（加法）和“multiplicative”（乘法）。默认为“additive”。
stan_backend (str) – 确定应该用于运行 Prophet 的后端。选项包括“CMDSTANPY”和“PYSTAN”。默认为“CMDSTANPY”。
interval_width (float) – 确定调用 get_prediction_intervals 时预测区间范围的置信度。接受 (0,1) 范围内的值。默认为 0.95。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “changepoint_prior_scale”: Real(0.001, 0.5), “seasonality_prior_scale”: Real(0.01, 10), “holidays_prior_scale”: Real(0.01, 10), “seasonality_mode”: [“additive”, “multiplicative”],}
model_family	ModelFamily.PROPHET
modifies_features	True
modifies_target	False
name	Prophet 回归器
supported_problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
training_only	False

方法

`build_prophet_df`	构建要传递给 fit 和 predict 的 Prophet 数据。
`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回一个长度为 1 的全 0 数组，因为 feature_importance 未定义用于 Prophet 回归器。
`拟合`	将 Prophet 回归器组件拟合到数据。
`get_params`	获取 Prophet 回归器的参数。
`获取预测区间`	使用拟合好的 ProphetRegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用拟合好的 Prophet 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

静态 build_prophet_df(X: pandas.DataFrame, y: Optional[pandas.Series] = None, time_index: str = 'ds') → pandas.DataFrame[来源]#: 构建要传递给 fit 和 predict 的 Prophet 数据。

clone(self)#

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

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

default_parameters(cls) → dict#

返回此组件的默认参数。

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

属性 feature_importance(self) → numpy.ndarray#: 返回长度为 1 的全 0 数组，因为 feature_importance 未定义用于 Prophet 回归器。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)[来源]#

将 Prophet 回归器组件拟合到数据。

参数

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

返回

self

get_params(self) → dict[source]#: 获取 Prophet 回归器的参数。

使用拟合好的 ProphetRegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上下界。
predictions (pd.Series) – 不用于 Prophet estimator。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

使用拟合好的 Prophet 回归器进行预测。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#

返回

预测值。

返回类型

pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.RandomForestClassifier(n_estimators=100, max_depth=6, n_jobs=-1, random_seed=0, **kwargs)[source]#

随机森林分类器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_depth (int) – 基学习器的最大树深。默认为 6。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “n_estimators”: Integer(10, 1000), “max_depth”: Integer(1, 10),}
model_family	ModelFamily.RANDOM_FOREST
modifies_features	True
modifies_target	False
name	随机森林分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.RandomForestRegressor(n_estimators: int = 100, max_depth: int = 6, n_jobs: int = -1, random_seed: Union[int, float] = 0, **kwargs)[source]#

随机森林回归器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_depth (int) – 基学习器的最大树深。默认为 6。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “n_estimators”: Integer(10, 1000), “max_depth”: Integer(1, 32),}
model_family	ModelFamily.RANDOM_FOREST
modifies_features	True
modifies_target	False
name	随机森林回归器
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回与每个特征关联的重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	使用拟合好的 RandomForestRegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

返回与每个特征关联的重要性。

返回: 与每个特征关联的重要性。
返回类型: np.ndarray
抛出: MethodPropertyNotFoundError – 如果估计器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

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

将估计器拟合到数据。

参数

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

返回

self

使用拟合好的 RandomForestRegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。可选。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.RegressionPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

所有回归管道的管道子类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中的组件重复时，重复组件的名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将变为 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
custom_name (str) – 管道的自定义名称。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = RegressionPipeline(component_graph=["Simple Imputer", "Linear Regressor"],
...                               parameters={"Simple Imputer": {"impute_strategy": "mean"}},
...                               custom_name="My Regression Pipeline")
...
>>> assert pipeline.custom_name == "My Regression Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Linear Regressor'}

管道参数将从每个组件的默认参数中选择，除非像上面那样传入了特定参数。

>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'mean', 'fill_value': None},
...     'Linear Regressor': {'fit_intercept': True, 'n_jobs': -1}}

属性

problem_type

ProblemTypes.REGRESSION

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	构建回归模型。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	使用选定的特征进行预测。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

构建回归模型。

参数

特征名称及其对应的重要性
y (pd.Series, np.ndarray) – 长度为 [n_samples] 的目标训练数据

返回

self

抛出

ValueError – 如果目标不是数字。

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)[source]#

使用选定的特征进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

预测值。

返回类型

pd.Series

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)[source]#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame, or np.ndarray) – 形状为 [n_samples, n_features] 的数据
y (pd.Series, or np.ndarray) – 长度为 [n_samples] 的真实值
objectives (list) – 用于评分的非空目标列表
X_train (pd.DataFrame) – 训练数据。忽略。仅用于时间序列。
y_train (pd.Series) – 训练标签。忽略。仅用于时间序列。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
用于进行预测的阈值。默认为 None。
transform(self, X, y=None)#
X (pd.DataFrame, or np.ndarray) – 数据，形状为 [n_samples, n_features]。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.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 or float) – 用于特征选择的阈值。重要性大于或等于阈值的特征将被保留，其他特征将被丢弃。如果为“median”，则阈值为特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
modifies_features	True
modifies_target	False
name	RF分类器特征选择
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

抛出

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

fit_transform(self, X, y=None)#

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

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

get_names(self)#

获取选定特征的名称。

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

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

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.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 or float) – 用于特征选择的阈值。重要性大于或等于阈值的特征将被保留，其他特征将被丢弃。如果为“median”，则阈值为特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_estimators (float) – 要构建的最大树数量。默认为 10。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
modifies_features	True
modifies_target	False
name	RF回归器特征选择
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

抛出

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

fit_transform(self, X, y=None)#

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

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

get_names(self)#

获取选定特征的名称。

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

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

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.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 (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “impute_strategy”: [“mean”, “median”, “most_frequent”]}
modifies_features	True
modifies_target	False
name	简单填充器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

参数

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

返回

self

抛出

ValueError – 如果 SimpleImputer 接收到包含布尔和分类数据的数据框。

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

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

通过填充缺失值来转换输入数据。‘None’ 和 np.nan 值被视为相同。

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.StackedEnsembleBase(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

堆叠集成基类。

参数

final_estimator (Estimator or subclass) – 用于组合基学习器的估计器。
n_jobs (int or None) – 用于流水线的并行级别整数描述。None 和 1 等效。如果设置为 -1，则使用所有 CPU。对于 n_jobs 大于 -1 的值，使用 (n_cpus + 1 + n_jobs)。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果是这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

model_family	ModelFamily.ENSEMBLE
modifies_features	True
modifies_target	False
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回堆叠集成类的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`name`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`supported_problem_types`	此估计器支持的问题类型。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回堆叠集成类的默认参数。

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

property supported_problem_types(cls)#: 此估计器支持的问题类型。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.StackedEnsembleClassifier(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

堆叠集成分类器。

参数

final_estimator (Estimator or subclass) – 用于组合基学习器的分类器。如果为 None，则使用 ElasticNetClassifier。
n_jobs (int or None) – 用于流水线的并行级别整数描述。None 和 1 等效。如果设置为 -1，则使用所有 CPU。对于 n_jobs 小于 -1 的值，使用 (n_cpus + 1 + n_jobs)。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果是这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> from evalml.pipelines.component_graph import ComponentGraph
>>> from evalml.pipelines.components.estimators.classifiers.decision_tree_classifier import DecisionTreeClassifier
>>> from evalml.pipelines.components.estimators.classifiers.elasticnet_classifier import ElasticNetClassifier
...
>>> component_graph = {
...     "Decision Tree": [DecisionTreeClassifier(random_seed=3), "X", "y"],
...     "Decision Tree B": [DecisionTreeClassifier(random_seed=4), "X", "y"],
...     "Stacked Ensemble": [
...         StackedEnsembleClassifier(n_jobs=1, final_estimator=DecisionTreeClassifier()),
...         "Decision Tree.x",
...         "Decision Tree B.x",
...         "y",
...     ],
... }
...
>>> cg = ComponentGraph(component_graph)
>>> assert cg.default_parameters == {
...     'Decision Tree Classifier': {'criterion': 'gini',
...                                  'max_features': 'sqrt',
...                                  'max_depth': 6,
...                                  'min_samples_split': 2,
...                                  'min_weight_fraction_leaf': 0.0},
...     'Stacked Ensemble Classifier': {'final_estimator': ElasticNetClassifier,
...                                     'n_jobs': -1}}

属性

超参数范围	{}
model_family	ModelFamily.ENSEMBLE
modifies_features	True
modifies_target	False
name	堆叠集成分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回堆叠集成类的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回堆叠集成类的默认参数。

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.StackedEnsembleRegressor(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

堆叠集成回归器。

参数

final_estimator (Estimator or subclass) – 用于组合基本估计器的回归器。如果为None，则使用ElasticNetRegressor。
n_jobs (int or None) – 用于流水线的并行级别整数描述。None 和 1 等效。如果设置为 -1，则使用所有 CPU。对于 n_jobs 大于 -1 的值，使用 (n_cpus + 1 + n_jobs)。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果是这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> from evalml.pipelines.component_graph import ComponentGraph
>>> from evalml.pipelines.components.estimators.regressors.rf_regressor import RandomForestRegressor
>>> from evalml.pipelines.components.estimators.regressors.elasticnet_regressor import ElasticNetRegressor
...
>>> component_graph = {
...     "Random Forest": [RandomForestRegressor(random_seed=3), "X", "y"],
...     "Random Forest B": [RandomForestRegressor(random_seed=4), "X", "y"],
...     "Stacked Ensemble": [
...         StackedEnsembleRegressor(n_jobs=1, final_estimator=RandomForestRegressor()),
...         "Random Forest.x",
...         "Random Forest B.x",
...         "y",
...     ],
... }
...
>>> cg = ComponentGraph(component_graph)
>>> assert cg.default_parameters == {
...     'Random Forest Regressor': {'n_estimators': 100,
...                                 'max_depth': 6,
...                                 'n_jobs': -1},
...     'Stacked Ensemble Regressor': {'final_estimator': ElasticNetRegressor,
...                                    'n_jobs': -1}}

属性

超参数范围	{}
model_family	ModelFamily.ENSEMBLE
modifies_features	True
modifies_target	False
name	堆叠集成回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回堆叠集成类的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用选定的特征进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回堆叠集成类的默认参数。

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: StackedEnsembleClassifier 和 StackedEnsembleRegressor 未实现此功能。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

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

通过去除均值并缩放到单位方差来标准化输入特征的转换器。

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

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	标准缩放器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [n_samples] 的目标训练数据。

返回

self

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

使用标准缩放器组件拟合并转换数据。

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

使用已拟合的标准缩放器转换数据。

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.SVMClassifier(C=1.0, kernel='rbf', gamma='auto', probability=True, random_seed=0, **kwargs)[source]#

支持向量机分类器。

参数

C (float) – 正则化参数。正则化强度与C成反比。必须严格为正。惩罚项为平方l2惩罚。默认为1.0。
kernel ({"poly", "rbf", "sigmoid"}) – 指定算法中使用的核函数类型。默认为“rbf”。
gamma ({"scale", "auto"} or float) – “rbf”、“poly”和“sigmoid”的核函数系数。默认为“auto”。- 如果传入gamma='scale'，则使用1 / (n_features * X.var()) 作为gamma的值 - 如果是“auto”（默认），则使用1 / n_features
probability (boolean) – 是否启用概率估计。默认为True。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “C”: Real(0, 10), “kernel”: [“poly”, “rbf”, “sigmoid”], “gamma”: [“scale”, “auto”],}
model_family	ModelFamily.SVM
modifies_features	True
modifies_target	False
name	SVM 分类器
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	特征重要性仅适用于线性核函数。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#

特征重要性仅适用于线性核函数。

如果核函数不是线性的，则返回全零的 numpy 数组。

返回: 已拟合的SVM分类器的特征重要性，如果核函数不是线性，则返回全零的 numpy 数组。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.SVMRegressor(C=1.0, kernel='rbf', gamma='auto', random_seed=0, **kwargs)[source]#

支持向量机回归器。

参数

C (float) – 正则化参数。正则化强度与C成反比。必须严格为正。惩罚项为平方l2惩罚。默认为1.0。
kernel ({"poly", "rbf", "sigmoid"}) – 指定算法中使用的核函数类型。默认为“rbf”。
gamma ({"scale", "auto"} or float) – “rbf”、“poly”和“sigmoid”的核函数系数。默认为“auto”。- 如果传入gamma='scale'，则使用1 / (n_features * X.var()) 作为gamma的值 - 如果是“auto”（默认），则使用1 / n_features
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{ “C”: Real(0, 10), “kernel”: [“poly”, “rbf”, “sigmoid”], “gamma”: [“scale”, “auto”],}
model_family	ModelFamily.SVM
modifies_features	True
modifies_target	False
name	SVM 回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合的SVM回归器的特征重要性。
`拟合`	将估计器拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#

已拟合的SVM回归器的特征重要性。

仅适用于线性核函数。如果核函数不是线性的，则返回全零的 numpy 数组。

返回: 已拟合的SVM回归器的特征重要性，如果核函数不是线性，则返回全零的 numpy 数组。

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

将估计器拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series#

使用选定的特征进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现 predict 的 component_obj。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.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 (int) – 随机数生成器的种子。默认为 0。

属性

超参数范围	{}
modifies_features	True
modifies_target	False
name	目标编码器
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	拟合目标编码器。
`拟合转换`	使用目标编码器拟合并转换数据。
`get_feature_names`	返回拟合后输入特征的特征名称。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [n_samples] 的目标训练数据。

返回

self

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

使用目标编码器拟合并转换数据。

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

get_feature_names(self)[source]#

返回拟合后输入特征的特征名称。

返回: 编码后的特征名称。
返回类型: np.array

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

使用已拟合的目标编码器转换数据。

参数

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

返回

转换后的数据。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.TimeSeriesBinaryClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

用于时间序列二元分类问题的管道基类。

参数

component_graph (list or dict) – 组件列表中组件的顺序。列表中接受字符串或 ComponentBase 子类。请注意，当列表中指定重复组件时，重复的组件名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 将具有名称 ["Imputer", "One Hot Encoder", "Imputer_2", "Logistic Regression Classifier"]
parameters (dict) – 以组件名称为键、以该组件参数字典为值的字典。空字典 {} 表示使用组件参数的所有默认值。管道级别的参数（如 time_index、gap 和 max_delay）必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = TimeSeriesBinaryClassificationPipeline(component_graph=["Simple Imputer", "Logistic Regression Classifier"],
...                                                   parameters={"Logistic Regression Classifier": {"penalty": "elasticnet",
...                                                                                                  "solver": "liblinear"},
...                                                               "pipeline": {"gap": 1, "max_delay": 1, "forecast_horizon": 1, "time_index": "date"}},
...                                                   custom_name="My TimeSeriesBinary Pipeline")
...
>>> assert pipeline.custom_name == "My TimeSeriesBinary Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Logistic Regression Classifier'}
...
>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'most_frequent', 'fill_value': None},
...     'Logistic Regression Classifier': {'penalty': 'elasticnet',
...                                         'C': 1.0,
...                                         'n_jobs': -1,
...                                         'multi_class': 'auto',
...                                         'solver': 'liblinear'},
...     'pipeline': {'gap': 1, 'max_delay': 1, 'forecast_horizon': 1, 'time_index': "date"}}

属性

problem_type

无

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测给定未来日期所需的日期。
`dates_needed_for_prediction_range`	返回预测给定未来日期所需的日期。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	拟合时间序列分类模型。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`优化阈值`	根据要使用的目标优化管道阈值。仅用于阈值可调的二元问题。
`参数`	此管道的参数字典。
`预测`	对目标未知未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`预测概率`	对目标未知的未来数据进行预测。
`predict_proba_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`阈值`	用于进行预测的阈值。默认为 None。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测给定未来日期所需的日期。

参数: date (pd.Timestamp) – 预测未来日期。
返回: 预测给定日期所需日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测给定未来日期所需的日期。

参数

start_date (pd.Timestamp) – 预测未来范围的开始日期。
end_date (pd.Timestamp) – 预测未来范围的结束日期。

返回

预测给定日期所需日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

fit(self, X, y)#

拟合时间序列分类模型。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

fit(self, X, y)#

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

optimize_threshold(self, X, y, y_pred_proba, objective)#

根据要使用的目标优化管道阈值。仅用于阈值可调的二元问题。

参数

管道名称。
new(self, parameters, random_seed=0)#
构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
此管道的新实例，具有相同的组件。

抛出

optimize_threshold(self, X, y, y_pred_proba, objective)#

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知未来数据进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最终组件不是 Estimator。

返回

预测。

predict_in_sample(self, X, y, X_train, y_train, objective=None)[source]#

对目标已知未来数据进行预测，例如交叉验证。

参数

X (pd.DataFrame) – 形状为 [n_samples, n_features] 的未来数据。
y (pd.Series) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame) – 用于训练管道的数据，形状为 [n_samples_train, n_feautures]。
y_train (pd.Series) – 用于训练管道的目标数据，形状为 [n_samples_train]。
objective (ObjectiveBase, str) – 用于对预测概率进行阈值处理的目标，可选。默认为 None。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

抛出

ValueError – 如果目标未针对时间序列二分类问题进行定义。

predict_proba(self, X, X_train=None, y_train=None)#

对目标未知的未来数据进行预测。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

predict_proba_in_sample(self, X_holdout, y_holdout, X_train, y_train)#

对目标已知未来数据进行预测，例如交叉验证。

参数

X_holdout (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
y_holdout (pd.Series, np.ndarray) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是 Estimator。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

property threshold(self)#: 用于进行预测的阈值。默认为 None。

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
y (pd.Series) – 与管道目标对应的目标。
X_train (pd.DataFrame) – 用于根据过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于根据过去的观测生成特征的训练目标。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.TimeSeriesClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

用于时间序列分类问题的管道基类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中的组件重复时，重复组件的名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将变为 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 以组件名称为键、以该组件参数字典为值的字典。空字典 {} 表示使用组件参数的所有默认值。管道级别的参数（如 time_index、gap 和 max_delay）必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

problem_type

无

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测给定未来日期所需的日期。
`dates_needed_for_prediction_range`	返回预测给定未来日期所需的日期。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	拟合时间序列分类模型。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	对目标未知未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`预测概率`	对目标未知的未来数据进行预测。
`predict_proba_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测给定未来日期所需的日期。

参数: date (pd.Timestamp) – 预测未来日期。
返回: 预测给定日期所需日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测给定未来日期所需的日期。

参数

start_date (pd.Timestamp) – 预测未来范围的开始日期。
end_date (pd.Timestamp) – 预测未来范围的结束日期。

返回

预测给定日期所需日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

拟合时间序列分类模型。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

fit(self, X, y)#

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知未来数据进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最终组件不是 Estimator。

返回

预测。

predict_in_sample(self, X, y, X_train, y_train, objective=None)[source]#

对目标已知未来数据进行预测，例如交叉验证。

objective (ObjectiveBase) – 用于确定阈值的目标。必须具有可调阈值。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
y (pd.Series, np.ndarray) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。
objective (ObjectiveBase, str, None) – 用于对预测概率进行阈值处理的目标，可选。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

predict_proba(self, X, X_train=None, y_train=None)[source]#

对目标未知的未来数据进行预测。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

predict_proba_in_sample(self, X_holdout, y_holdout, X_train, y_train)[source]#

对目标已知未来数据进行预测，例如交叉验证。

参数

X_holdout (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
y_holdout (pd.Series, np.ndarray) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是 Estimator。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)[source]#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
y (pd.Series) – 与管道目标对应的目标。
X_train (pd.DataFrame) – 用于根据过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于根据过去的观测生成特征的训练目标。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.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 (*str*) – 包含用于排序数据的日期时间信息的列名。忽略。
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_{}
超参数范围	{ “conf_level”: Real(0.001, 1.0), “rolling_window_size”: Real(0.001, 1.0)}:type: {“conf_level”
modifies_features	True
modifies_target	False
name	时间序列特征提取器
需要拟合	True
target_colname_prefix	target_delay_{}
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

拟合 DelayFeatureTransformer。

参数

特征名称及其对应的重要性
y (pd.Series, optional) – 目标训练数据，长度为 [n_samples]

返回

self

抛出

ValueError – 如果 self.time_index 为 None

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

拟合组件并转换输入数据。

参数

X (pd.DataFrame) – 要转换的数据。
y (*pd.Series*, 或 *None*) – 目标变量。

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

static load(file_path)#

从文件路径加载组件。

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

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

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – 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。不返回原始特征。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.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*) – 用于字符串、对象、布尔型、分类 dtypes 的插补策略。有效值包括“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 (int) – 随机数生成器的种子。默认为 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”],}
modifies_features	True
modifies_target	True
name	时间序列插补器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

通过使用指定的时间序列特定策略插补缺失值来转换数据 X。在插补之前，将“None”值转换为 np.nan 并视为相同。

参数

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

返回

转换后的 X 和 y

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.TimeSeriesMulticlassClassificationPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

用于时间序列多元分类问题的管道基类。

参数

component_graph (list or dict) – 组件列表中组件的顺序。列表中接受字符串或 ComponentBase 子类。请注意，当列表中指定重复组件时，重复的组件名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 将具有名称 ["Imputer", "One Hot Encoder", "Imputer_2", "Logistic Regression Classifier"]
parameters (dict) – 以组件名称为键、以该组件参数字典为值的字典。空字典 {} 表示使用组件参数的所有默认值。管道级别的参数（如 time_index、gap 和 max_delay）必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = TimeSeriesMulticlassClassificationPipeline(component_graph=["Simple Imputer", "Logistic Regression Classifier"],
...                                                       parameters={"Logistic Regression Classifier": {"penalty": "elasticnet",
...                                                                                                      "solver": "liblinear"},
...                                                                   "pipeline": {"gap": 1, "max_delay": 1, "forecast_horizon": 1, "time_index": "date"}},
...                                                       custom_name="My TimeSeriesMulticlass Pipeline")
>>> assert pipeline.custom_name == "My TimeSeriesMulticlass Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Logistic Regression Classifier'}
>>> assert pipeline.parameters == {
...  'Simple Imputer': {'impute_strategy': 'most_frequent', 'fill_value': None},
...  'Logistic Regression Classifier': {'penalty': 'elasticnet',
...                                     'C': 1.0,
...                                     'n_jobs': -1,
...                                     'multi_class': 'auto',
...                                     'solver': 'liblinear'},
...     'pipeline': {'gap': 1, 'max_delay': 1, 'forecast_horizon': 1, 'time_index': "date"}}

属性

problem_type

ProblemTypes.TIME_SERIES_MULTICLASS

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`classes_`	获取管道的类别名称。在管道拟合之前将返回 None。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测给定未来日期所需的日期。
`dates_needed_for_prediction_range`	返回预测给定未来日期所需的日期。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	拟合时间序列分类模型。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	对目标未知未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`预测概率`	对目标未知的未来数据进行预测。
`predict_proba_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

property classes_(self)#: 获取管道的类别名称。在管道拟合之前将返回 None。

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测给定未来日期所需的日期。

参数: date (pd.Timestamp) – 预测未来日期。
返回: 预测给定日期所需日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测给定未来日期所需的日期。

参数

start_date (pd.Timestamp) – 预测未来范围的开始日期。
end_date (pd.Timestamp) – 预测未来范围的结束日期。

返回

预测给定日期所需日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

fit(self, X, y)#

拟合时间序列分类模型。

参数

特征名称及其对应的重要性
pd.DataFrame

返回

self

抛出

fit(self, X, y)#

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知未来数据进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最终组件不是 Estimator。

返回

预测。

predict_in_sample(self, X, y, X_train, y_train, objective=None)#

对目标已知未来数据进行预测，例如交叉验证。

objective (ObjectiveBase) – 用于确定阈值的目标。必须具有可调阈值。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
y (pd.Series, np.ndarray) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。
objective (ObjectiveBase, str, None) – 用于对预测概率进行阈值处理的目标，可选。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

predict_proba(self, X, X_train=None, y_train=None)#

对目标未知的未来数据进行预测。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

predict_proba_in_sample(self, X_holdout, y_holdout, X_train, y_train)#

对目标已知未来数据进行预测，例如交叉验证。

参数

X_holdout (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的未来数据。
y_holdout (pd.Series, np.ndarray) – 形状为 [n_samples] 的未来目标。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

估计概率。

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是 Estimator。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
y (pd.Series) – 与管道目标对应的目标。
X_train (pd.DataFrame) – 用于根据过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于根据过去的观测生成特征的训练目标。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.TimeSeriesRegressionPipeline(component_graph, parameters=None, custom_name=None, random_seed=0)[source]#

用于时间序列回归问题的管道基类。

参数

component_graph (ComponentGraph, list, dict) – ComponentGraph 实例、按顺序排列的组件列表或组件字典。接受列表中的字符串或 ComponentBase 子类。请注意，当列表中的组件重复时，重复组件的名称将根据其在列表中的索引进行修改。例如，组件图 [Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] 的名称将变为 [“Imputer”, “One Hot Encoder”, “Imputer_2”, “Logistic Regression Classifier”]
parameters (dict) – 以组件名称为键、以该组件参数字典为值的字典。空字典 {} 表示使用组件参数的所有默认值。管道级别的参数（如 time_index、gap 和 max_delay）必须使用“pipeline”键指定。例如：Pipeline(parameters={“pipeline”: {“time_index”: “Date”, “max_delay”: 4, “gap”: 2}})。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> pipeline = TimeSeriesRegressionPipeline(component_graph=["Simple Imputer", "Linear Regressor"],
...                                                       parameters={"Simple Imputer": {"impute_strategy": "mean"},
...                                                                   "pipeline": {"gap": 1, "max_delay": 1, "forecast_horizon": 1, "time_index": "date"}},
...                                                       custom_name="My TimeSeriesRegression Pipeline")
...
>>> assert pipeline.custom_name == "My TimeSeriesRegression Pipeline"
>>> assert pipeline.component_graph.component_dict.keys() == {'Simple Imputer', 'Linear Regressor'}

管道参数将从每个组件的默认参数中选择，除非像上面那样传入了特定参数。

>>> assert pipeline.parameters == {
...     'Simple Imputer': {'impute_strategy': 'mean', 'fill_value': None},
...     'Linear Regressor': {'fit_intercept': True, 'n_jobs': -1},
...     'pipeline': {'gap': 1, 'max_delay': 1, 'forecast_horizon': 1, 'time_index': "date"}}

属性

NO_PREDS_PI_ESTIMATORS	ProblemTypes.TIME_SERIES_REGRESSION
problem_type	无

方法

`can_tune_threshold_with_objective`	确定二元分类管道的阈值是否可以调整。
`克隆`	构造一个具有相同组件、参数和随机种子的新管道。
`create_objectives`	从字符串列表或目标类创建目标实例。
`custom_name`	管道的自定义名称。
`dates_needed_for_prediction`	返回预测给定未来日期所需的日期。
`dates_needed_for_prediction_range`	返回预测给定未来日期所需的日期。
`描述`	输出管道详细信息，包括组件参数。
`特征重要性`	与每个特征关联的重要性。特征选择丢弃的特征将被排除。
`拟合`	拟合时间序列管道。
`拟合转换`	如果所有组件都是转换器，则拟合并转换组件图中的所有组件。
`获取组件`	按名称返回组件。
`get_forecast_period`	根据 X 中的最新数据点生成所有可能的预测时间点。
`get_forecast_predictions`	根据 X 的最后周期生成所有可能的预测预测。
`获取超参数范围`	以字典形式返回所有组件的超参数范围。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`图`	生成表示管道图的图像。
`图字典`	生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。
`图示特征重要性`	生成管道特征重要性的条形图。
`逆转换`	以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。
`加载`	从文件路径加载管道。
`model_family`	返回此管道的模型族。
`name`	管道名称。
`新建`	构造一个具有相同组件图但参数集不同的新管道实例。不要与 Python 的 __new__ 方法混淆。
`参数`	此管道的参数字典。
`预测`	对目标未知未来数据进行预测。
`predict_in_sample`	对目标已知未来数据进行预测，例如交叉验证。
`保存`	将管道保存到文件路径。
`评分`	评估模型在当前目标和附加目标上的性能。
`摘要`	管道结构的简短摘要，描述使用的组件列表。
`转换`	转换输入。
`转换除最终组件外的所有组件`	通过应用所有预处理组件来转换数据。

can_tune_threshold_with_objective(self, objective)#

确定二元分类管道的阈值是否可以调整。

参数: objective (ObjectiveBase) – 主要的 AutoMLSearch 目标。
返回: 如果管道阈值可调，则为 True。
返回类型: bool

clone(self)#

构造一个具有相同组件、参数和随机种子的新管道。

返回: clone(self)#

static create_objectives(objectives)#: 从字符串列表或目标类创建目标实例。

property custom_name(self)#: 管道的自定义名称。

dates_needed_for_prediction(self, date)#

返回预测给定未来日期所需的日期。

参数: date (pd.Timestamp) – 预测未来日期。
返回: 预测给定日期所需日期范围。
返回类型: dates_needed (tuple(pd.Timestamp))

dates_needed_for_prediction_range(self, start_date, end_date)#

返回预测给定未来日期所需的日期。

参数

start_date (pd.Timestamp) – 预测未来范围的开始日期。
end_date (pd.Timestamp) – 预测未来范围的结束日期。

返回

预测给定日期所需日期范围。

返回类型

dates_needed (tuple(pd.Timestamp))

抛出

ValueError – 如果 start_date 不在 end_date 之前

describe(self, return_dict=False)#

输出管道详细信息，包括组件参数。

参数: property custom_name(self)#
返回: 管道的自定义名称。
返回类型: dict

property feature_importance(self)#

与每个特征关联的重要性。特征选择丢弃的特征将被排除。

返回: return_dict (bool) – 如果为 True，则返回包含管道信息的字典。默认为 False。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

拟合时间序列管道。

参数

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

返回

self

抛出

ValueError – 如果目标不是数字。

fit_transform(self, X, y)#

如果所有组件都是转换器，则拟合并转换组件图中的所有组件。

参数

TypeError – 如果 dtype 是布尔型但序列中存在 pd.NA。
Exception – 对于所有其他异常。

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

X (pd.DataFrame) – 输入特征，形状为 [n_samples, n_features]。

get_component(self, name)#

按名称返回组件。

参数: 转换后的输出。
返回: ValueError – 如果最终组件是估计器。
返回类型: get_component(self, name)#

get_forecast_period(self, X)[source]#

根据 X 中的最新数据点生成所有可能的预测时间点。

参数: X (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]。
抛出: ValueError – 如果管道未训练。
返回: 从 gap 到 forecast_horizon + gap 的日期时间周期。
返回类型: pd.Series

示例

>>> X = pd.DataFrame({'date': pd.date_range(start='1-1-2022', periods=10, freq='D'), 'feature': range(10, 20)})
>>> y = pd.Series(range(0, 10), name='target')
>>> gap = 1
>>> forecast_horizon = 2
>>> pipeline = TimeSeriesRegressionPipeline(component_graph=["Linear Regressor"],
...                                         parameters={"Simple Imputer": {"impute_strategy": "mean"},
...                                                     "pipeline": {"gap": gap, "max_delay": 1, "forecast_horizon": forecast_horizon, "time_index": "date"}},
...                                        )
>>> pipeline.fit(X, y)
pipeline = TimeSeriesRegressionPipeline(component_graph={'Linear Regressor': ['Linear Regressor', 'X', 'y']}, parameters={'Linear Regressor':{'fit_intercept': True, 'n_jobs': -1}, 'pipeline':{'gap': 1, 'max_delay': 1, 'forecast_horizon': 2, 'time_index': 'date'}}, random_seed=0)
>>> dates = pipeline.get_forecast_period(X)
>>> expected = pd.Series(pd.date_range(start='2022-01-11', periods=forecast_horizon, freq='D').shift(gap), name='date', index=[10, 11])
>>> assert dates.equals(expected)

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

根据 X 的最后周期生成所有可能的预测预测。

参数

X (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]。
y (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

从 gap 周期到 forecast_horizon + gap 周期的预测。

get_hyperparameter_ranges(self, custom_hyperparameters)#

以字典形式返回所有组件的超参数范围。

参数: 要返回的组件
返回: Component
返回类型: dict

get_prediction_intervals(self, X, y=None, X_train=None, y_train=None, coverage=None)[source]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标数据。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_features]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

graph(self, filepath=None)#

生成表示管道图的图像。

参数

custom_hyperparameters (dict) – 管道的自定义超参数。

返回

管道中每个组件的超参数范围字典。

返回类型

graph(self, filepath=None)#

抛出

filepath (str, optional) – 图形应保存到的路径。如果设置为 None（默认），则图形不会保存。
可以直接在 Jupyter Notebook 中显示的图形对象。

graph_dict(self)#

生成一个字典，其中节点由组件名称和参数组成，边详细说明组件关系。在大多数情况下，此字典可进行 JSON 序列化。

RuntimeError – 如果未安装 graphviz。

返回: ValueError – 如果路径不可写。
返回类型: graph_dict(self)#

graph_feature_importance(self, importance_threshold=0)#

表示 DAG 结构的字典。

参数: dag_dict (dict)
返回: graph_feature_importance(self, importance_threshold=0)#
返回类型: 生成管道特征重要性的条形图。
抛出: importance_threshold (float, optional) – 如果提供，则绘制其置换重要性绝对值大于 importance_threshold 的特征。默认为零。

inverse_transform(self, y)#

以相反的顺序将组件的 inverse_transform 方法应用于估计器的预测结果。

plotly.Figure

参数: ValueError – 如果重要性阈值无效。
返回: inverse_transform(self, y)#
返回类型: pd.Series

static load(file_path: Union[str, io.BytesIO])#

从文件路径加载管道。

参数: y (pd.Series) – 最终组件特征。
返回: 目标的逆转换结果。

property model_family(self)#: 返回此管道的模型族。

property name(self)#: 管道名称。

new(self, parameters, random_seed=0)#

property model_family(self)#

参数

parameters (dict) – 字典，以组件名称为键，以该组件参数的字典为值。空字典或 None 表示使用组件参数的所有默认值。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

返回

返回此管道的模型族。

property parameters(self)#

此管道的参数字典。

返回: y (pd.Series) – 输入目标值。
返回类型: dict

predict(self, X, objective=None, X_train=None, y_train=None)#

对目标未知未来数据进行预测。

参数

property summary(self)#
ValueError – 如果目标不可优化。
X_train (pd.DataFrame or np.ndarray or None) – 训练数据。
y_train (pd.Series or None) – 训练标签。

抛出

ValueError – 如果 X_train 和/或 y_train 为 None，或者最终组件不是 Estimator。

返回

预测。

predict_in_sample(self, X, y, X_train, y_train, objective=None, calculating_residuals=False)#

对目标已知未来数据进行预测，例如交叉验证。

参数

X (pd.DataFrame or np.ndarray) – 未来数据，形状为 [n_samples, n_features]
y (pd.Series, np.ndarray) – 未来目标，形状为 [n_samples]
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]
objective (ObjectiveBase, str, None) – 用于对预测概率进行阈值处理的目标，可选。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

predict(self, X, objective=None, X_train=None, y_train=None)#

返回类型

pd.Series

抛出

ValueError – 如果最终组件不是估计器。

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

将管道保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

score(self, X, y, objectives, X_train=None, y_train=None)[source]#

评估模型在当前目标和附加目标上的性能。

参数

X (pd.DataFrame or np.ndarray) – 数据，形状为 [n_samples, n_features]。
y (pd.Series) – 真实标签，长度为 [n_samples]。
objectives (list) – 用于评分的非空目标列表。
X_train (pd.DataFrame, np.ndarray) – 管道训练时使用的数据，形状为 [n_samples_train, n_feautures]。
y_train (pd.Series, np.ndarray) – 用于训练管道的目标，形状为 [n_samples_train]。

返回

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

返回类型

dict

property summary(self)#

管道结构的简短摘要，描述使用的组件列表。

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]

返回: y (pd.Series) – 真实标签，长度为 [n_samples]

transform(self, X, y=None)#

转换输入。

参数

property summary(self)#
示例：逻辑回归分类器 w/ 简单填充器 + 独热编码器

返回

fit_transform(self, X, y)#

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

transform_all_but_final(self, X, y=None, X_train=None, y_train=None, calculating_residuals=False)#

通过应用所有预处理组件来转换数据。

参数

property threshold(self)#
y (pd.Series) – 与管道目标对应的目标。
X_train (pd.DataFrame) – 用于根据过去的观测生成特征的训练数据。
y_train (pd.Series) – 用于根据过去的观测生成特征的训练目标。
calculating_residuals (bool) – 是否正在调用 predict_in_sample 计算残差。这意味着 X 和 y 参数不是未来数据，而是实际的训练数据。

返回

y (pd.Series) – 目标数据，长度为 [n_samples]。默认为 None。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

class evalml.pipelines.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 列完全可推断，则此转换器将不执行任何操作并返回原始的 X 和 y。

如果 X 没有完全可推断的频率，但可以估算出一个频率，那么将根据 time_index 的估算频率重新格式化 X 和 y。在传入的原始 X 和 y 中：- 将添加缺失的日期时间值，并在 X 和 y 中将其对应列设置为 None。- 将删除重复的日期时间值。- 将删除额外的日期时间值。- 如果可以确定重复或额外的值是错位的，则将其重新定位以取代缺失值的位置。

此转换器应在 TimeSeriesImputer 之前使用，以便插补已添加到 X 和 y 中的缺失值（如果传入）。

如果用于多序列数据集，则特别适用于未堆叠的数据集。

参数

time_index (*string*) – 包含用于排序数据的日期时间信息的列名，必需。默认为 None。
frequency_payload (*tuple*) – Woodwork 的 infer_frequency 函数（debug 为 True）返回的载荷。默认为 None。
window_length (*int*) – 用于推断不可推断频率普遍性的滚动窗口大小。
5. (较低的值使得此组件对识别大量错误日期时间值更敏感。默认为)
threshold (*float*) – 能够推断出频率的窗口的最小百分比。较低的值使得此组件更
0.8。(对识别大量错误日期时间值更敏感。默认为)
random_seed (*int*) – 随机数生成器的种子。此转换器无论提供何种随机种子，其行为都相同。
0。(默认为)

抛出

ValueError – 如果 frequency_payload 参数未传递元组。

属性

超参数范围	{}
modifies_features	True
modifies_target	True
name	时间序列规范器
training_only	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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 长度为 [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。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

将数据框和目标数据规范化到可推断的偏移频率。

基于可推断的偏移频率创建一个“干净”的 X 和 y（如果 y 传入），并将与原始 X 和 y 匹配的日期时间值插补到干净的 X 和 y 中。识别为错位的日期时间值将被移动到其适当的位置。

参数

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

返回

具有可推断 time_index 偏移频率的数据。

返回类型

(pd.DataFrame, pd.Series)

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.Transformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

可能需要或不需要拟合来转换数据的组件。这些组件在估计器之前使用。

要实现新的 Transformer，请定义您自己的 Transformer 子类，包括名称和在 AutoML 搜索期间要调整的任何参数（超参数）的接受范围列表。定义一个 __init__ 方法，该方法设置任何必要的状态和对象。确保您的 __init__ 仅使用标准关键字参数，并使用 parameters 字典调用 super().__init__()。如果合适，您还可以覆盖此类中的 fit、transform、fit_transform 和其他方法。

要查看一些示例，请查看任何 Transformer 组件的定义。

参数

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

属性

modifies_features	True
modifies_target	False
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`拟合`	将组件拟合到数据。
`拟合转换`	在 X 上拟合并转换 X。
`加载`	从文件路径加载组件。
`name`	返回此组件的字符串名称。
`需要拟合`	返回布尔值，判断组件在调用 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 (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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, optional) – 目标训练数据，长度为 [n_samples]

返回

self

抛出

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

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

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: 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 (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

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

转换数据 X。

参数

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

返回

转换后的 X

返回类型

如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

抛出

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.VARMAXRegressor(time_index: Optional[Hashable] = None, p: int = 1, q: int = 0, trend: Optional[str] = 'c', random_seed: Union[int, float] = 0, maxiter: int = 10, use_covariates: bool = False, **kwargs)[source]#

带有外生回归器的向量自回归移动平均模型。两个参数 (p, q) 是 AR 阶数和 MA 阶数。更多信息请参见：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。

目前 VARMAXRegressor 不支持通过 conda 安装。建议通过 PyPI 安装。

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
p (*int*) – 最大自回归阶数。默认为 1。
q (*int*) – 最大移动平均阶数。默认为 0。
trend (str) – 控制确定性趋势。选项包括 [‘n’, ‘c’, ‘t’, ‘ct’]，其中 ‘c’ 是常数项，‘t’ 表示线性趋势，‘ct’ 表示两者都有。定义多项式时也可以是可迭代对象，例如 [1, 1, 0, 1]。
random_seed (int) – 随机数生成器的种子。默认为 0。
max_iter (*int*) – 求解器的最大迭代次数。默认为 10。
use_covariates (*bool*) – 如果为 True，将在 fit/predict 方法中传递外生变量。如果为 False，预测将完全基于日期时间和目标值。默认为 True。

属性

超参数范围	{ “p”: Integer(1, 10), “q”: Integer(1, 10), “trend”: Categorical([‘n’, ‘c’, ‘t’, ‘ct’]),}
model_family	ModelFamily.VARMAX
modifies_features	True
modifies_target	False
name	VARMAX 回归器
supported_problem_types	[ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	返回长度为 1 的零数组，因为未为 VARMAX 回归器定义 feature_importance。
`拟合`	将 VARMAX 回归器拟合到数据。
`获取预测区间`	使用拟合的 VARMAXRegressor 查找预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用拟合的 VARMAX 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → numpy.ndarray#: 返回长度为 1 的零数组，因为未为 VARMAX 回归器定义 feature_importance。

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

将 VARMAX 回归器拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
y (*pd.DataFrane*) – 形状为 [n_samples, n_series_id_values] 的目标训练数据。

返回

self

抛出

ValueError – 如果未传入 y。

get_prediction_intervals(self, X: pandas.DataFrame, y: pandas.DataFrame = None, coverage: List[float] = None, predictions: pandas.Series =None) → Dict[str, pandas.Series][source]#

使用拟合的 VARMAXRegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (*pd.DataFrame*) – 形状为 [n_samples, n_series_id_values] 的目标数据。可选。
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
predictions (*pd.Series*) – 不用于 VARMAX 回归器。

返回

一个包含预测区间的字典，格式为 {series_id: {coverage}_lower 或 {coverage}_upper}。

返回类型

dict[dict]

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

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

使用拟合的 VARMAX 回归器进行预测。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (*pd.DataFrame*) – 形状为 [n_samples, n_series_id_values] 的目标数据。

返回

预测值。

返回类型

pd.Series

抛出

ValueError – 如果 X 在 fit 中传入但未在 predict 中传入。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.XGBoostClassifier(eta=0.1, max_depth=6, min_child_weight=1, n_estimators=100, random_seed=0, eval_metric='logloss', n_jobs=12, **kwargs)[source]#

XGBoost 分类器。

参数

eta (float) – 提升学习率。默认为 0.1。
max_depth (int) – 基学习器的最大树深。默认为 6。
min_child_weight (float) – 子节点中所需的最小实例权重（hessian）总和。默认为 1.0
n_estimators (int) – 梯度提升树的数量。等同于提升轮次。默认为 100。
random_seed (int) – 随机数生成器的种子。默认为 0。
n_jobs (int) – 运行 xgboost 时使用的并行线程数。请注意，创建线程争用会显著降低算法速度。默认为 12。

属性

超参数范围	{ “eta”: Real(0.000001, 1), “max_depth”: Integer(1, 10), “min_child_weight”: Real(1, 10), “n_estimators”: Integer(1, 1000),}
model_family	ModelFamily.XGBOOST
modifies_features	True
modifies_target	False
name	XGBoost 分类器
SEED_MAX	无
SEED_MIN	无
supported_problem_types	silent (boolean) – 是否使用“静默”日志模式。默认为 True。
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合的 XGBoost 分类器的特征重要性。
`拟合`	将 XGBoost 分类器组件拟合到数据。
`获取预测区间`	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 XGBoost 分类器进行预测。
`预测概率`	ModelFamily.CATBOOST
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#: 已拟合的 XGBoost 分类器的特征重要性。

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

将 XGBoost 分类器组件拟合到数据。

参数

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

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}

clone(self)#

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (list[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

抛出

property feature_importance(self)#

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X)[source]#

使用已拟合的 XGBoost 分类器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

predict_proba(self, X)[source]#

ModelFamily.CATBOOST

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: 如果 return_dict 为 True，则返回所有组件参数的字典，否则返回 None。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

class evalml.pipelines.XGBoostRegressor(eta: float = 0.1, max_depth: int = 6, min_child_weight: int = 1, n_estimators: int = 100, random_seed: Union[int, float] = 0, n_jobs: int = 12, **kwargs)[source]#

XGBoost 回归器。

参数

eta (float) – 提升学习率。默认为 0.1。
max_depth (int) – 基学习器的最大树深。默认为 6。
min_child_weight (float) – 子节点中所需的最小实例权重（hessian）总和。默认为 1.0
n_estimators (int) – 梯度提升树的数量。等同于提升轮次。默认为 100。
random_seed (int) – 随机数生成器的种子。默认为 0。
n_jobs (int) – 运行 xgboost 时使用的并行线程数。请注意，创建线程争用会显著降低算法速度。默认为 12。

属性

超参数范围	{ “eta”: Real(0.000001, 1), “max_depth”: Integer(1, 20), “min_child_weight”: Real(1, 10), “n_estimators”: Integer(1, 1000),}
model_family	ModelFamily.XGBOOST
modifies_features	True
modifies_target	False
name	XGBoost 回归器
SEED_MAX	无
SEED_MIN	无
supported_problem_types	[ 问题类型.回归, 问题类型.时间序列回归, 问题类型.多序列时间序列回归,]
training_only	False

方法

`克隆`	构造一个具有相同参数和随机状态的新组件。
`默认参数`	返回此组件的默认参数。
`描述`	描述一个组件及其参数。
`特征重要性`	已拟合的 XGBoost 回归器的特征重要性。
`拟合`	将 XGBoost 回归器组件拟合到数据。
`获取预测区间`	使用已拟合的 XGBoostRegressor 找到预测区间。
`加载`	从文件路径加载组件。
`需要拟合`	返回布尔值，判断组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`参数`	返回用于初始化组件的参数。
`预测`	使用已拟合的 XGBoost 回归器进行预测。
`预测概率`	为标签生成概率估计。
`保存`	将组件保存到文件路径。
`更新参数`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#: 已拟合的 XGBoost 回归器的特征重要性。

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

将 XGBoost 回归器组件拟合到数据。

参数

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

返回

self

使用已拟合的 XGBoostRegressor 找到预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
default_parameters(cls)#
coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上下界。
describe(self, print_name=False, return_dict=False)#

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

对于不需要拟合或其拟合方法不执行任何操作的组件，此方法可以被覆盖为 False。

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series[source]#

使用已拟合的 XGBoost 回归器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

为标签生成概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
抛出: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

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

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, optional) – 如果为 True，则将 _is_fitted 设置为 False。

管道#

子包#

子模块#

包内容#

类摘要#

目录#