估计器

EvalML 估计器组件。

子包

• 分类器
  • 基线分类器
  • CatBoost 分类器
  • 决策树分类器
  • Elastic Net 分类器
  • ET 分类器
  • K 近邻分类器
  • LightGBM 分类器
  • 逻辑回归分类器
  • RF 分类器
  • SVM 分类器
  • XGBoost 分类器
• 回归器
  • ARIMA 回归器
  • 基线回归器
  • CatBoost 回归器
  • 决策树回归器
  • Elastic Net 回归器
  • ET 回归器
  • 指数平滑回归器
  • LightGBM 回归器
  • 线性回归器
  • 多序列时间序列基线回归器
  • Prophet 回归器
  • RF 回归器
  • SVM 回归器
  • 时间序列基线估计器
  • VARMAX 回归器
  • XGBoost 回归器

子模块

• 估计器

包内容

类摘要

ARIMARegressor	自回归积分滑动平均模型。三个参数 (p, d, q) 分别是 AR 阶数、差分阶数和 MA 阶数。更多信息请见此处：https://statsmodels.cn/devel/generated/statsmodels.tsa.arima.model.ARIMA.html。
BaselineClassifier	使用指定策略进行预测的分类器。
BaselineRegressor	使用简单策略进行预测的基线回归器。这可作为与其他回归器进行比较的简单基线回归器使用。
CatBoostClassifier	CatBoost 分类器，一种使用决策树梯度提升的分类器。CatBoost 是一个开源库，原生支持分类特征。
CatBoostRegressor	CatBoost 回归器，一种使用决策树梯度提升的回归器。CatBoost 是一个开源库，原生支持分类特征。
DecisionTreeClassifier	决策树分类器。
DecisionTreeRegressor	决策树回归器。
ElasticNetClassifier	Elastic Net 分类器。使用带有 elasticnet 惩罚的逻辑回归作为基础估计器。
ElasticNetRegressor	Elastic Net 回归器。
Estimator	一个拟合和预测给定数据的组件。
ExponentialSmoothingRegressor	Holt-Winters 指数平滑预测器。
ExtraTreesClassifier	Extra Trees 分类器。
ExtraTreesRegressor	Extra Trees 回归器。
KNeighborsClassifier	K 近邻分类器。
LightGBMClassifier	LightGBM 分类器。
LightGBMRegressor	LightGBM 回归器。
LinearRegressor	线性回归器。
LogisticRegressionClassifier	逻辑回归分类器。
MultiseriesTimeSeriesBaselineRegressor	使用朴素预测方法进行预测的多序列时间序列回归器。
ProphetRegressor	Prophet 是一种基于加法模型的预测时间序列数据的过程，该模型通过年度、每周和每日的季节性以及假期效应来拟合非线性趋势。它最适用于具有强烈季节性效应和多个季节历史数据的时间序列。Prophet 对缺失数据和趋势变化具有鲁棒性，并且通常能很好地处理异常值。
RandomForestClassifier	随机森林分类器。
RandomForestRegressor	随机森林回归器。
SVMClassifier	支持向量机分类器。
SVMRegressor	支持向量机回归器。
TimeSeriesBaselineEstimator	使用朴素预测方法进行预测的时间序列估计器。
VARMAXRegressor	带有外生回归器的向量自回归滑动平均模型。两个参数 (p, q) 分别是 AR 阶数和 MA 阶数。更多信息请见此处：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。
XGBoostClassifier	XGBoost 分类器。
XGBoostRegressor	XGBoost 回归器。

目录

class evalml.pipelines.components.estimators.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)

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

当前，ARIMARegressor 不支持通过 conda 安装。建议通过 PyPI 进行安装。

参数

• time_index (str) – 指定 X 中提供 datetime 对象的列名。默认为 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。

属性

hyperparameter_ranges	{ “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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回长度为 1 的全零数组，因为 feature_importance 对于 ARIMA 回归器未定义。
fit	将 ARIMA 回归器拟合到数据。
get_prediction_intervals	使用已拟合的 ARIMARegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用已拟合的 ARIMA 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → numpy.ndarray

返回长度为 1 的全零数组，因为 feature_importance 对于 ARIMA 回归器未定义。

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

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

使用已拟合的 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 之前是否需要拟合。

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

使用已拟合的 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.components.estimators.BaselineClassifier(strategy='mode', random_seed=0, **kwargs)

使用指定策略进行预测的分类器。

这作为一个简单的基线分类器，用于与其他分类器进行比较，非常有用。

参数

• strategy (str) – 用于预测的方法。有效选项包括 “mode”、“random” 和 “random_weighted”。默认为 “mode”。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
model_family	ModelFamily.BASELINE
modifies_features	True
modifies_target	False
name	基线分类器
supported_problem_types	[ProblemTypes.BINARY, ProblemTypes.MULTICLASS]
training_only	False

方法

classes_	返回类别标签。拟合前返回 None。
clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。由于基线分类器不使用输入特征来计算预测，因此返回一个全零数组。
fit	将基线分类器组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用基线分类策略进行预测。
predict_proba	使用基线分类策略进行预测概率。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

property classes_(self)

返回类别标签。拟合前返回 None。

返回

类别名称

返回类型

list[str] or list(float)

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 or dict

property feature_importance(self)

返回与每个特征相关的特征重要性。由于基线分类器不使用输入特征来计算预测，因此返回一个全零数组。

返回

一个全零数组

返回类型

pd.Series

fit(self, X, y=None)

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

参数

• X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。

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

返回

self

引发

ValueError – 如果 y 为 None。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

使用基线分类策略进行预测。

参数

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

返回

预测值。

返回类型

pd.Series

predict_proba(self, X)

使用基线分类策略进行预测概率。

参数

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

返回

预测概率值。

返回类型

pd.DataFrame

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.components.estimators.BaselineRegressor(strategy='mean', random_seed=0, **kwargs)

使用简单策略进行预测的基线回归器。这可作为与其他回归器进行比较的简单基线回归器使用。

参数

• strategy (str) – 用于预测的方法。有效选项包括 “mean”、“median”。默认为 “mean”。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
model_family	ModelFamily.BASELINE
modifies_features	True
modifies_target	False
name	基线回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。由于基线回归器不使用输入特征来计算预测，因此返回一个全零数组。
fit	将基线回归组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用基线回归策略进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

返回与每个特征相关的特征重要性。由于基线回归器不使用输入特征来计算预测，因此返回一个全零数组。

返回

一个全零数组。

返回类型

np.ndarray (float)

fit(self, X, y=None)

将基线回归组件拟合到数据。

参数

• X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。

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

返回

self

引发

ValueError – 如果输入 y 为 None。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

使用基线回归策略进行预测。

参数

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.components.estimators.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)

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

更多信息请访问 https://catboost.ai/

参数

• n_estimators (float) – 要构建的最大树数量。默认为 10。

• eta (float) – 学习率。默认为 0.03。

• max_depth (int) – 基本学习器的最大树深度。默认为 6。

• bootstrap_type (string) – 定义对象权重采样的方法。可用方法包括 'Bayesian'、'Bernoulli'、'MVS'。默认为 None。

• silent (boolean) – 是否使用“静默”日志模式。默认为 True。

• allow_writing_files (boolean) – 训练期间是否允许写入快照文件。默认为 False。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
model_family	ModelFamily.CATBOOST
modifies_features	True
modifies_target	False
name	CatBoost 分类器
supported_problem_types	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合好的 CatBoost 分类器的特征重要性。
fit	将 CatBoost 分类器组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合好的 CatBoost 分类器进行预测。
predict_proba	使用拟合好的 CatBoost 分类器进行预测概率。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

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

fit(self, X, y=None)

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

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

参数

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

返回

预测值。

返回类型

pd.Series

predict_proba(self, X)

使用拟合好的 CatBoost 分类器进行预测概率。

参数

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

返回

预测概率值。

返回类型

pd.DataFrame

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.components.estimators.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)

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

更多信息请访问 https://catboost.ai/

参数

• n_estimators (float) – 要构建的最大树数量。默认为 10。

• eta (float) – 学习率。默认为 0.03。

• max_depth (int) – 基本学习器的最大树深度。默认为 6。

• bootstrap_type (string) – 定义对象权重采样的方法。可用方法包括 'Bayesian'、'Bernoulli'、'MVS'。默认为 None。

• silent (boolean) – 是否使用“静默”日志模式。默认为 True。

• allow_writing_files (boolean) – 训练期间是否允许写入快照文件。默认为 False。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
model_family	ModelFamily.CATBOOST
modifies_features	True
modifies_target	False
name	CatBoost 回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合好的 CatBoost 回归器的特征重要性。
fit	将 CatBoost 回归组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合好的 CatBoost 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

拟合好的 CatBoost 回归器的特征重要性。

fit(self, X, y=None)

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

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

参数

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

返回

预测值。

返回类型

pd.DataFrame

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.components.estimators.DecisionTreeClassifier(criterion='gini', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)

决策树分类器。

参数

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

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.DecisionTreeRegressor(criterion='squared_error', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)

决策树回归器。

参数

• criterion ({"squared_error", "friedman_mse", "absolute_error", "poisson"}) –

  衡量分割质量的函数。支持的标准包括：

  • “squared_error”，用于均方误差，等于方差减小作为特征选择标准，并使用每个终端节点的平均值最小化 L2 损失。

  • “friedman_mse”，使用弗里德曼改进分数的均方误差进行潜在分割。

  • “absolute_error”，用于平均绝对误差，它使用每个终端节点的中位数最小化 L1 损失，

  • “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。

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.ElasticNetClassifier(penalty='elasticnet', C=1.0, l1_ratio=0.15, multi_class='auto', solver='saga', n_jobs=-1, random_seed=0, **kwargs)

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”，即使数据是二分类的，也会最小化整个概率分布上的多项式损失。当 solver="liblinear" 时，“multinomial”不可用。“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。

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合好的弹性网络分类器的特征重要性。
fit	将弹性网络分类器组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

拟合好的弹性网络分类器的特征重要性。

fit(self, X, y)

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

参数

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.ElasticNetRegressor(alpha=0.0001, l1_ratio=0.15, max_iter=1000, random_seed=0, **kwargs)

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。

属性

hyperparameter_ranges	{ “alpha”: Real(0, 1), “l1_ratio”: Real(0, 1),}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	Elastic Net 回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合后的 ElasticNet 回归器的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

拟合后的 ElasticNet 回归器的特征重要性。

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]

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.Estimator(parameters: dict = None, component_obj: Type[evalml.pipelines.components.ComponentBase] = None, random_seed: Union[int, float] = 0, **kwargs)

一个拟合和预测给定数据的组件。

要实现新的估计器，请定义自己的类，该类是 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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
model_family	ModelFamily.NONE
name	返回此组件的字符串名称。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
supported_problem_types	此估计器支持的问题类型。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

property model_family(cls)

返回此组件的模型族。

property name(cls)

返回此组件的字符串名称。

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.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)

Holt-Winters 指数平滑预测器。

当前通过 conda install 不支持 ExponentialSmoothingRegressor。建议通过 PyPI 安装。

参数

• trend (str) – 趋势组件类型。默认为 None。

• damped_trend (bool) – 如果趋势组件应该被阻尼。默认为 False。

• seasonal (str) – 季节性组件类型。取值为 {“additive”, None} 中的一个。如果

• 目标数据不为 0，也可以是乘法的，

• 但 AutoMLSearch 不会对此进行调优。默认为 None。

• sp (int) – 要考虑的季节周期数。默认为 2。

• n_jobs (int or None) – 描述用于管道的并行级别。非负整数。默认为 -1。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回长度为 1 的 0 数组，因为指数平滑回归器未定义特征重要性。
fit	将指数平滑回归器拟合到数据。
get_prediction_intervals	使用拟合后的 ExponentialSmoothingRegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合后的指数平滑回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → pandas.Series

返回长度为 1 的 0 数组，因为指数平滑回归器未定义特征重要性。

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

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

参数

• X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。忽略。

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

返回

self

引发

ValueError – 如果未传入 y。

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

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

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

参数

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

• y (pd.Series) – 目标数据。可选。

• coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。

• predictions (pd.Series) – 未用于指数平滑回归器。

返回

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

返回类型

dict

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

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

参数

• 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.components.estimators.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)

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。

• min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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	额外树分类器
supported_problem_types	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.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)

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。

• min_weight_fraction_leaf (float) – 叶节点所需的总权重（所有输入样本的权重总和）的最小加权分数。默认为 0.0。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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	额外树回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合后的 ExtraTreesRegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

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

参数

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

• y (pd.Series) – 目标数据。可选。

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.KNeighborsClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, random_seed=0, **kwargs)

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。

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与输入特征数量匹配的 0 数组，因为 KNN 分类器未定义特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

返回与输入特征数量匹配的 0 数组，因为 KNN 分类器未定义特征重要性。

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]

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

使用选定特征进行预测。

参数

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

返回

预测值。

返回类型

pd.Series

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

为标签进行概率估计。

参数

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.components.estimators.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)

LightGBM 分类器。

参数

• boosting_type (string) – 要使用的 Boosting 类型。默认为“gbdt”。 - ‘gbdt’ 使用传统梯度提升决策树 - “dart” 使用 Dropouts meet Multiple Additive Regression Trees - “goss” 使用基于梯度的单侧采样 - “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。

属性

hyperparameter_ranges	{ “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.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将 LightGBM 分类器组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合的 LightGBM 分类器进行预测。
predict_proba	使用拟合的 LightGBM 分类器进行概率预测。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → pandas.Series

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

返回

与每个特征相关的特征重要性。

返回类型

np.ndarray

引发

MethodPropertyNotFoundError – 如果估算器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

fit(self, X, y=None)

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

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

参数

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

返回

预测值。

返回类型

pd.DataFrame

predict_proba(self, X)

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

参数

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

返回

预测概率值。

返回类型

pd.DataFrame

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.components.estimators.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)

LightGBM 回归器。

参数

• boosting_type (string) – 要使用的 Boosting 类型。默认为“gbdt”。 - ‘gbdt’ 使用传统梯度提升决策树 - “dart” 使用 Dropouts meet Multiple Additive Regression Trees - “goss” 使用基于梯度的单侧采样 - “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。

属性

hyperparameter_ranges	{ “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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将 LightGBM 回归器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合的 LightGBM 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → pandas.Series

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

返回

与每个特征相关的特征重要性。

返回类型

np.ndarray

引发

MethodPropertyNotFoundError – 如果估算器没有 feature_importance 方法或实现 feature_importance 的 component_obj。

fit(self, X, y=None)

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

使用拟合的 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.components.estimators.LinearRegressor(fit_intercept=True, n_jobs=-1, random_seed=0, **kwargs)

线性回归器。

参数

• fit_intercept (boolean) – 是否为该模型计算截距。如果设置为 False，计算中将不使用截距（即数据应以中心化）。默认为 True。

• n_jobs (int or None) – 并行运行的任务数。-1 使用所有线程。默认为 -1。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “fit_intercept”: [True, False],}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	线性回归器
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合的线性回归器的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.LogisticRegressionClassifier(penalty='l2', C=1.0, multi_class='auto', solver='lbfgs', n_jobs=-1, random_seed=0, **kwargs)

逻辑回归分类器。

参数

• penalty ({"l1", "l2", "elasticnet", "none"}) – 惩罚中使用的范数。默认为“l2”。

• C (float) – 正则化强度的倒数。必须是正浮点数。默认为 1.0。

• multi_class ({"auto", "ovr", "multinomial"}) – 如果选择“ovr”，则为每个标签拟合一个二分类问题。对于“multinomial”，即使数据是二分类的，也会最小化整个概率分布上的多项式损失。当 solver="liblinear" 时，“multinomial”不可用。“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。

属性

hyperparameter_ranges	{ “penalty”: [“l2”], “C”: Real(0.01, 10),}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	逻辑回归分类器
supported_problem_types	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合的逻辑回归分类器的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.MultiseriesTimeSeriesBaselineRegressor(gap=1, forecast_horizon=1, random_seed=0, **kwargs)

使用朴素预测方法进行预测的多序列时间序列回归器。

这在多系列时间序列问题中作为一个简单的基线估计器很有用。

参数

• gap (int) – 预测日期和目标日期之间的间隔，必须是正整数。如果 gap 为 0，目标日期将提前一个时间周期。默认为 1。

• forecast_horizon (int) – 模型预期预测的时间步数。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
model_family	ModelFamily.BASELINE
modifies_features	True
modifies_target	False
name	多系列时间序列基线回归器
supported_problem_types	[ ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将多系列时间序列基线回归器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合的多系列时间序列基线回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

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

由于基线估计器不使用输入特征来计算预测，因此返回一个零数组。

返回

一个全零数组。

返回类型

np.ndarray (float)

fit(self, X, y=None)

将多系列时间序列基线回归器拟合到数据。

参数

• X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features * n_series]。

• y (pd.DataFrame) – 目标训练数据，形状为 [n_samples, n_features * n_series]。

返回

self

引发

ValueError – 如果输入 y 为 None，或者 y 不是具有多个列的 DataFrame。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

使用拟合的多系列时间序列基线回归器进行预测。

参数

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

返回

预测值。

返回类型

pd.DataFrame

引发

ValueError – 如果滞后列不存在于 X 中。

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.components.estimators.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 中提供 datetime 对象的列名。默认为 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) – 确定此组件如何拟合季节性。选项包括“加性”和“乘性”。默认为“加性”。

• stan_backend (str) – 确定应使用哪个后端来运行 Prophet。选项包括“CMDSTANPY”和“PYSTAN”。默认为“CMDSTANPY”。

• interval_width (float) – 确定调用 get_prediction_intervals 时预测区间范围的置信度。接受范围 (0,1) 内的值。默认为 0.95。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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	构建 Prophet 数据以用于拟合和预测。
clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	由于 Prophet 回归器未定义 feature_importance，因此返回长度为 1 的零数组。
fit	将 Prophet 回归器组件拟合到数据。
get_params	获取 Prophet 回归器的参数。
get_prediction_intervals	使用拟合的 ProphetRegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合的 Prophet 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

static build_prophet_df(X: pandas.DataFrame, y: Optional[pandas.Series] = None, time_index: str = 'ds') → pandas.DataFrame

构建 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 or dict

property feature_importance(self) → numpy.ndarray

由于 Prophet 回归器未定义 feature_importance，因此返回长度为 1 的零数组。

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

获取 Prophet 回归器的参数。

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

使用拟合的 ProphetRegressor 找到预测区间。

参数

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

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

• coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。

• predictions (pd.Series) – 不用于 Prophet 估计器。

返回

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

返回类型

dict

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

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

参数

• 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.components.estimators.RandomForestClassifier(n_estimators=100, max_depth=6, n_jobs=-1, random_seed=0, **kwargs)

随机森林分类器。

参数

• n_estimators (float) – 森林中的树数量。默认为 100。

• max_depth (int) – 基学习器的最大树深度。默认为 6。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.RandomForestRegressor(n_estimators: int = 100, max_depth: int = 6, n_jobs: int = -1, random_seed: Union[int, float] = 0, **kwargs)

随机森林回归器。

参数

• n_estimators (float) – 森林中的树数量。默认为 100。

• max_depth (int) – 基学习器的最大树深度。默认为 6。

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

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “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	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用已拟合的 RandomForestRegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用已拟合的 RandomForestRegressor 找到预测区间。

参数

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

• y (pd.Series) – 目标数据。可选。

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.SVMClassifier(C=1.0, kernel='rbf', gamma='auto', probability=True, random_seed=0, **kwargs)

支持向量机分类器。

参数

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

属性

hyperparameter_ranges	{ “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.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	特征重要性仅适用于线性核。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.SVMRegressor(C=1.0, kernel='rbf', gamma='auto', random_seed=0, **kwargs)

支持向量机回归器。

参数

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

属性

hyperparameter_ranges	{ “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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	已拟合 SVM 回归器的特征重要性。
fit	将估算器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用选定特征进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

已拟合 SVM 回归器的特征重要性。

仅适用于线性核。如果核不是线性的，则返回一个包含零的 numpy 数组。

返回

已拟合 SVM 回归器的特征重要性，如果核不是线性的，则返回一个包含零的数组。

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]

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

对于不需要拟合或其 fit 方法不执行任何操作的组件，可以将其重写为 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.components.estimators.TimeSeriesBaselineEstimator(gap=1, forecast_horizon=1, random_seed=0, **kwargs)

使用朴素预测方法进行预测的时间序列估计器。

这对于时间序列问题来说是一个简单的基准估计器。

参数

• gap (int) – 预测日期和目标日期之间的间隔，必须是正整数。如果 gap 为 0，目标日期将提前一个时间周期。默认为 1。

• forecast_horizon (int) – 模型预期预测的时间步数。

• random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
model_family	ModelFamily.BASELINE
modifies_features	True
modifies_target	False
name	时间序列基准估计器
supported_problem_types	[ ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回与每个特征相关的特征重要性。
fit	将时间序列基准估计器拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用已拟合的时间序列基准估计器进行预测。
predict_proba	使用已拟合的时间序列基准估计器进行概率预测。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

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

由于基线估计器不使用输入特征来计算预测，因此返回一个零数组。

返回

一个全零数组。

返回类型

np.ndarray (float)

fit(self, X, y=None)

将时间序列基准估计器拟合到数据。

参数

• X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。

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

返回

self

引发

ValueError – 如果输入 y 为 None。

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)#

使用已拟合的时间序列基准估计器进行预测。

参数

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

返回

预测值。

返回类型

pd.Series

引发

ValueError – 如果输入 y 为 None。

predict_proba(self, X)#

使用已拟合的时间序列基准估计器进行概率预测。

参数

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

返回

预测概率值。

返回类型

pd.DataFrame

引发

ValueError – 如果输入 y 为 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.components.estimators.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)

带有外生回归器的向量自回归滑动平均模型。两个参数 (p, q) 分别是 AR 阶数和 MA 阶数。更多信息请见此处：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。

目前，通过 conda install 不支持 VARMAXRegressor。建议通过 PyPI 进行安装。

参数

• time_index (str) – 指定 X 中提供 datetime 对象的列名。默认为 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。

属性

hyperparameter_ranges	{ “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

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	返回长度为 1 的全零数组，因为 VARMAX 回归器未定义 feature_importance。
fit	将 VARMAX 回归器拟合到数据。
get_prediction_intervals	使用已拟合的 VARMAXRegressor 找到预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用已拟合的 VARMAX 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → numpy.ndarray

返回长度为 1 的全零数组，因为 VARMAX 回归器未定义 feature_importance。

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

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

使用已拟合的 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 之前是否需要拟合。

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

使用已拟合的 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.components.estimators.XGBoostClassifier(eta=0.1, max_depth=6, min_child_weight=1, n_estimators=100, random_seed=0, eval_metric='logloss', n_jobs=12, **kwargs)

XGBoost 分类器。

参数

• eta (float) – Boosting 学习率。默认为 0.1。

• max_depth (int) – 基学习器的最大树深度。默认为 6。

• min_child_weight (float) – 子节点中所需的实例权重（海森）的最小总和。默认为 1.0

• n_estimators (int) – 梯度提升树的数量。等同于 boosting 轮数。默认为 100。

• random_seed (int) – 随机数生成器的种子。默认为 0。

• n_jobs (int) – 运行 xgboost 使用的并行线程数。注意，创建线程竞争会显著降低算法速度。默认为 12。

属性

hyperparameter_ranges	{ “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	None
SEED_MIN	None
supported_problem_types	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	已拟合 XGBoost 分类器的特征重要性。
fit	将 XGBoost 分类器组件拟合到数据。
get_prediction_intervals	使用拟合的回归器查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用已拟合的 XGBoost 分类器进行预测。
predict_proba	使用拟合好的 CatBoost 分类器进行预测。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self)

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

fit(self, X, y=None)

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

使用拟合的回归器查找预测区间。

此函数使用拟合的回归器计算预测区间。它通过使用窗口大小为 5 来计算所有预测的滚动标准差。上下预测值是通过取下尾概率在每个边界处的百分点（分位数）函数乘以滚动标准差来确定的。

参数

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

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

• coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

引发

MethodPropertyNotFoundError – 如果估算器不支持时间序列回归作为问题类型。

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

predict(self, X)

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

参数

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

返回

预测值。

返回类型

pd.DataFrame

predict_proba(self, X)

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

参数

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

返回

预测值。

返回类型

pd.DataFrame

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.components.estimators.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)

XGBoost 回归器。

参数

• eta (float) – Boosting 学习率。默认为 0.1。

• max_depth (int) – 基学习器的最大树深度。默认为 6。

• min_child_weight (float) – 子节点中所需的实例权重（海森）的最小总和。默认为 1.0

• n_estimators (int) – 梯度提升树的数量。等同于 boosting 轮数。默认为 100。

• random_seed (int) – 随机数生成器的种子。默认为 0。

• n_jobs (int) – 运行 xgboost 使用的并行线程数。注意，创建线程竞争会显著降低算法速度。默认为 12。

属性

hyperparameter_ranges	{ “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	None
SEED_MIN	None
supported_problem_types	[ ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION,]
training_only	False

方法

clone	使用相同的参数和随机状态构造一个新组件。
default_parameters	返回此组件的默认参数。
describe	描述组件及其参数。
feature_importance	拟合后的 XGBoost 回归器的特征重要性。
fit	将 XGBoost 回归器组件拟合到数据。
get_prediction_intervals	使用拟合后的 XGBoostRegressor 查找预测区间。
load	从文件路径加载组件。
needs_fitting	返回布尔值，指示组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
parameters	返回用于初始化组件的参数。
predict	使用拟合后的 XGBoost 回归器进行预测。
predict_proba	为标签进行概率估计。
save	将组件保存到文件路径。
update_parameters	更新组件的参数字典。

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 or dict

property feature_importance(self) → pandas.Series

拟合后的 XGBoost 回归器的特征重要性。

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

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

参数

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

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

参数

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

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

• coverage (List[float]) – 一个包含 0 到 1 之间浮点数的列表，用于计算预测区间的上限和下限。

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

返回

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

返回类型

dict

static load(file_path)

从文件路径加载组件。

参数

file_path (str) – 加载文件的位置。

返回

ComponentBase 对象

needs_fitting(self)

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

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

返回

True。

property parameters(self)

返回用于初始化组件的参数。

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

使用拟合后的 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。