组件#

EvalML 组件类。

子包#

子模块#

包内容#

类摘要#

`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 是一个开源库，原生支持分类特征。
`ComponentBase`	所有组件的基类。
`ComponentBaseMeta`	通过使用验证器和设置器包装方法来覆盖创建新组件的元类。
`DateTimeFeaturizer`	可以自动从日期时间列提取特征的转换器。
`DecisionTreeClassifier`	决策树分类器。
`DecisionTreeRegressor`	决策树回归器。
`DFSTransformer`	Featuretools DFS 组件，用于为输入特征生成特征。
`DropColumns`	删除输入数据中指定的列。
`DropNaNRowsTransformer`	删除具有 NaN 值的行的转换器。
`DropNullColumns`	删除 NaN 值百分比超过指定阈值的特征的转换器。
`DropRowsTransformer`	删除由行索引指定的行的转换器。
`ElasticNetClassifier`	Elastic Net 分类器。使用带有 elasticnet 惩罚项的逻辑回归作为基础估计器。
`ElasticNetRegressor`	Elastic Net 回归器。
`EmailFeaturizer`	可以自动从电子邮件提取特征的转换器。
`Estimator`	拟合并预测给定数据的组件。
`ExponentialSmoothingRegressor`	Holt-Winters 指数平滑预测器。
`ExtraTreesClassifier`	Extra Trees 分类器。
`ExtraTreesRegressor`	Extra Trees 回归器。
`FeatureSelector`	根据重要性权重选择最重要的特征。
`Imputer`	根据指定的填补策略填补缺失数据。
`KNeighborsClassifier`	K 近邻分类器。
`LabelEncoder`	一个转换器，使用 0 到 num_classes - 1 之间的值对目标标签进行编码。
`LightGBMClassifier`	LightGBM 分类器。
`LightGBMRegressor`	LightGBM 回归器。
`LinearDiscriminantAnalysis`	使用线性判别分析减少特征数量。
`LinearRegressor`	线性回归器。
`LogisticRegressionClassifier`	逻辑回归分类器。
`LogTransformer`	对目标数据应用对数变换。
`LSA`	用于计算文本输入潜在语义分析值 (LSA) 的转换器。
`MultiseriesTimeSeriesBaselineRegressor`	使用朴素预测方法进行预测的多序列时间序列回归器。
`NaturalLanguageFeaturizer`	可以使用 featuretools 的 nlp_primitives 自动对文本列进行特征工程的转换器。
`OneHotEncoder`	一个将分类特征编码为 one-hot 数字数组的转换器。
`OrdinalEncoder`	一个将有序特征编码为表示类别相对顺序的有序整数数组的转换器。
`Oversampler`	SMOTE 过采样器组件。将根据组件的输入自动选择使用 SMOTE、SMOTEN 或 SMOTENC。
`PCA`	使用主成分分析 (PCA) 减少特征数量。
`PerColumnImputer`	根据每列指定的填补策略填补缺失数据。
`PolynomialDecomposer`	通过对数据拟合多项式和移动平均线来去除时间序列中的趋势和季节性。
`ProphetRegressor`	Prophet 是一种基于加法模型的时间序列数据预测方法，其中非线性趋势与年度、每周和每日季节性以及节假日效应相结合。它最适用于具有强季节性效应和数个季节历史数据的时间序列。Prophet 对缺失数据和趋势变化具有鲁棒性，并且通常能很好地处理异常值。
`RandomForestClassifier`	随机森林分类器。
`RandomForestRegressor`	随机森林回归器。
`ReplaceNullableTypes`	用与 EvalML 兼容的数据类型替换具有新的可空数据类型的特征的转换器。
`RFClassifierRFESelector`	使用带有随机森林分类器的递归特征消除来选择相关特征。
`RFClassifierSelectFromModel`	使用随机森林分类器根据重要性权重选择最重要的特征。
`RFRegressorRFESelector`	使用带有随机森林回归器的递归特征消除来选择相关特征。
`RFRegressorSelectFromModel`	使用随机森林回归器根据重要性权重选择最重要的特征。
`SelectByType`	根据输入数据中指定的 Woodwork 逻辑类型或语义标签选择列。
`SelectColumns`	选择输入数据中指定的列。
`SimpleImputer`	根据指定的填补策略填补缺失数据。忽略自然语言列。
`StackedEnsembleBase`	Stacked Ensemble 基类。
`StackedEnsembleClassifier`	Stacked Ensemble 分类器。
`StackedEnsembleRegressor`	Stacked Ensemble 回归器。
`StandardScaler`	一个通过去除均值并缩放到单位方差来标准化输入特征的转换器。
`STLDecomposer`	使用 STL 算法去除时间序列中的趋势和季节性。
`SVMClassifier`	支持向量机分类器。
`SVMRegressor`	支持向量机回归器。
`TargetEncoder`	一个将分类特征编码为目标编码的转换器。
`TargetImputer`	根据指定的填补策略填补缺失目标数据。
`TimeSeriesBaselineEstimator`	使用朴素预测方法进行预测的时间序列估计器。
`TimeSeriesFeaturizer`	对时间序列问题的输入特征和目标变量进行延迟的转换器。
`TimeSeriesImputer`	根据指定的时间序列特定填补策略填补缺失数据。
`TimeSeriesRegularizer`	对间隔不一致的日期时间列进行正则化的转换器。
`Transformer`	可能需要或不需要拟合来转换数据的组件。这些组件在估计器之前使用。
`Undersampler`	初始化一个下采样转换器，用于对数据集中的多数类进行下采样。
`URLFeaturizer`	可以自动从 URL 提取特征的转换器。
`VARMAXRegressor`	带有外生回归器的向量自回归移动平均模型。两个参数 (p, q) 分别是 AR 阶数和 MA 阶数。更多信息请见：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。
`XGBoostClassifier`	XGBoost 分类器。
`XGBoostRegressor`	XGBoost 回归器。

目录#

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

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

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

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
trend (str) – 控制确定性趋势。选项包括 [‘n’, ‘c’, ‘t’, ‘ct’]，其中 ‘c’ 表示常数项，‘t’ 表示线性趋势，‘ct’ 表示两者都有。在定义多项式时也可以是可迭代对象，例如 [1, 1, 0, 1]。
start_p (int) – 最小自回归阶数。默认为 2。
d (int) – 最小差分阶数。默认为 0。
start_q (int) – 最小移动平均阶数。默认为 2。
max_p (int) – 最大自回归阶数。默认为 5。
max_d (int) – 最大差分阶数。默认为 2。
max_q (int) – 最大移动平均阶数。默认为 5。
seasonal (boolean) – 是否对 ARIMA 拟合季节性模型。默认为 True。
sp (int 或 str) – 季节性差分的周期，具体指每个季节中的周期数。如果为“detect”，该模型将自动检测此参数（如果时间序列是标准频率），如果无法检测到，则会回退到 1（无季节性）。默认为 1。
n_jobs (int 或 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 的全零数组，因为 ARIMA 回归器未定义 feature_importance。
`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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

将 ARIMA 回归器拟合到数据。

参数

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

返回

self

引发

ValueError – 如果未传入 y。

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

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

参数

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

返回

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

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

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

参数

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

返回

预测值。

返回类型

pd.Series

引发

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

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

对标签进行概率估计。

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

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.BaselineClassifier(strategy='mode', random_seed=0, **kwargs)[source]#

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

这作为与其他分类器进行比较的简单基准分类器很有用。

参数

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] 或 list(float)

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

property feature_importance(self)#

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

返回: 全零数组
返回类型: pd.Series

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

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

predict_proba(self, X)[source]#

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

参数: 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.BaselineRegressor(strategy='mean', random_seed=0, **kwargs)[source]#

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

参数

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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#

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

返回: 全零数组。
返回类型: np.ndarray (float)

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

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

参数

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

参数: 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

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 或 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

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

返回

self

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

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

predict_proba(self, X)[source]#

使用拟合的 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

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

更多信息，请访问 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 或 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

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

返回

self

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

使用拟合的 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

所有组件的基类。

参数

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

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`load`	从文件路径加载组件。
`modifies_features`	返回此组件在转换期间是否修改（子集化或转换）特征变量。
`modifies_target`	返回此组件在转换期间是否修改（子集化或转换）目标变量。
`name`	返回此组件的字符串名称。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`training_only`	返回此组件是仅在训练时进行评估，还是在训练和预测时都进行评估。
`update_parameters`	更新组件的参数字典。

clone(self)[source]#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将组件拟合到数据。

参数

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

返回

self

引发

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

static load(file_path)[source]#

从文件路径加载组件。

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

property modifies_features(cls)#

返回此组件在转换期间是否修改（子集化或转换）特征变量。

对于 Estimator 对象，此属性决定了来自 `predict` 或 `predict_proba` 的返回值是否应被用作特征或目标。

property modifies_target(cls)#

返回此组件在转换期间是否修改（子集化或转换）目标变量。

对于 Estimator 对象，此属性决定了来自 `predict` 或 `predict_proba` 的返回值是否应被用作特征或目标。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

property training_only(cls)#: 返回此组件是仅在训练时进行评估，还是在训练和预测时都进行评估。

update_parameters(self, update_dict, reset_fit=True)[source]#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.ComponentBaseMeta[source]#

通过使用验证器和设置器包装方法来覆盖创建新组件的元类。

属性

FIT_METHODS	[`fit`, `fit_transform`]
METHODS_TO_CHECK	[`predict`, `predict_proba`, `transform`, `inverse_transform`, `get_trend_dataframe`]
PROPERTIES_TO_CHECK	[`feature_importance`]

方法

`check_for_fit`	`check_for_fit` 封装了一个方法，该方法验证 `self._is_fitted` 是否为 `True`。
`register`	注册 ABC 的虚拟子类。
`set_fit`	fit 方法的包装器。

classmethod check_for_fit(cls, method)[source]#

`check_for_fit` 封装了一个方法，该方法验证 `self._is_fitted` 是否为 `True`。

如果为 `False` 则抛出异常，如果为 `True` 则调用并返回被封装的方法。

参数: method (callable) – 要封装的方法。
返回: 被封装的方法。
引发: ComponentNotYetFittedError – 如果组件尚未拟合。

register(cls, subclass)#

返回子类，允许作为类装饰器使用。

classmethod set_fit(cls, method)#: fit 方法的包装器。

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

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

参数

features_to_extract (list) – 要提取的特征列表。有效选项包括“year”、“month”、“day_of_week”、“hour”。默认为 None。
encode_as_categories (bool) – 星期和月份特征是否应编码为 pandas “category” 数据类型。这允许 OneHotEncoders 对这些特征进行编码。默认为 False。
time_index (str) – 包含用于数据排序的日期时间信息的列名。忽略。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	日期时间特征器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

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

参数

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

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

get_feature_names(self)[source]#

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

返回

字典，其中每个键值对是一个列名和一个将唯一特征值映射到其整数编码的字典。: mapping the unique feature values to their integer encoding.

返回类型

dict

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

(pd.DataFrame, pd.Series)

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

决策树分类器。

参数

class evalml.pipelines.components.DecisionTreeClassifier(criterion='gini', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)[source]#
criterion ({"gini", "entropy"}) – 衡量分割质量的函数。支持的标准有衡量基尼不纯度的“gini”和衡量信息增益的“entropy”。默认为“gini”。
max_features (int, float or {"sqrt", "log2"}) –
- 寻找最佳分割时考虑的特征数量
- 如果是 int 类型，则在每次分割时考虑 max_features 个特征。
- 如果是 float 类型，则 max_features 是一个分数，并在每次分割时考虑 int(max_features * n_features) 个特征。
- 如果是“sqrt”，则 max_features=sqrt(特征数)。
- 如果是“log2”，则 max_features=log2(特征数)。
如果是 None，则 max_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。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	min_weight_fraction_leaf (float) – 叶节点所需的（所有输入样本）总权重之和的最小加权分数。默认为 0.0。
model_family	{ “criterion”: [“gini”, “entropy”], “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
modifies_features	True
modifies_target	False
name	ModelFamily.DECISION_TREE
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)#

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

y (pd.Series, optional) – 目标训练数据，长度为 [样本数]。

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

参数

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 – 如果估计器不支持时间序列回归问题类型。

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

从文件路径加载组件。

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

static load(file_path)#

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

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

返回: True。

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

property parameters(self)#

将估计器拟合到数据。

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

MethodPropertyNotFoundError – 如果估计器没有 predict 方法或实现了 predict 方法的 component_obj。

对标签进行概率估计。

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

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

将组件保存到文件路径。

参数

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

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

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

决策树回归器。

参数

class evalml.pipelines.components.DecisionTreeRegressor(criterion='squared_error', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)[source]#
criterion ({"squared_error", "friedman_mse", "absolute_error", "poisson"}) –
- 衡量分割质量的函数。支持的标准有
- “squared_error”表示均方误差，它等于方差减小作为特征选择标准，并使用每个终端节点的均值最小化 L2 损失
- “friedman_mse”，它使用均方误差以及 Friedman 改进分数来进行潜在分割
- “absolute_error”表示平均绝对误差，它使用每个终端节点的中位数最小化 L1 损失，
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(特征数)。
- 如果是“log2”，则 max_features=log2(特征数)。
如果是 None，则 max_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。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	“poisson”，它使用泊松偏差的减小来寻找分割点。
model_family	{ “criterion”: [“gini”, “entropy”], “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
modifies_features	True
modifies_target	False
name	{ “criterion”: [“squared_error”, “friedman_mse”, “absolute_error”], “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
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)#

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

property feature_importance(self) → pandas.Series#

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

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

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

参数

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 – 如果估计器不支持时间序列回归问题类型。

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

从文件路径加载组件。

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

static load(file_path)#

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

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

返回: True。

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

property parameters(self)#

将估计器拟合到数据。

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

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

对标签进行概率估计。

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

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

将组件保存到文件路径。

参数

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

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

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

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

参数

class evalml.pipelines.components.DFSTransformer(index='index', features=None, random_seed=0, **kwargs)[source]#
random_seed (int) – 随机数生成器的种子。默认为 0。
index (string) – 包含索引的列的名称。如果不存在具有此名称的列，则 featuretools.EntitySet() 将创建一个同名列作为索引列。默认为“index”。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	features (list) – 要运行 DFS 的特征列表。默认为 None。只有当特征使用的列存在于输入中且特征本身不在输入中时，才会计算特征。如果 features 是一个空列表，则输入数据不会发生转换。
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`DFS 转换器`	contains_pre_existing_features
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	确定 DFS 转换器中的特征是否与管道输入特征匹配。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	拟合 DFSTransformer 转换器组件。
`update_parameters`	更新组件的参数字典。

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

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

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

clone(self)#

contains_pre_existing_features

参数

static contains_pre_existing_features(dfs_features: Optional[List[featuretools.feature_base.FeatureBase]], input_feature_names: List[str], target: Optional[str] = None)[source]#
dfs_features (Optional[List[FeatureBase]]) – DFS 转换器的输出特征列表。
input_feature_names (List[str]) – 输入到 DFS 转换器的特征列表。

target (Optional[str]) – 我们尝试预测其值的目标。这用于了解如果在 DFS 转换器的参数中的特征列表中存在目标列，则应忽略哪一列。

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

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

参数

fit(self, X, y=None)[source]#
y (pd.Series) – 目标训练数据，长度为 [n_samples]。

返回

self

X (pd.DataFrame, np.array) – 要转换的输入数据，形状为 [样本数, 特征数]。

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

fit_transform(self, X, y=None)#

从文件路径加载组件。

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

static load(file_path)#

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

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

返回: True。

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

property parameters(self)#

将组件保存到文件路径。

参数

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

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

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

参数

使用 featuretools 的 dfs 算法计算输入 X 的特征矩阵。
y (pd.Series, optional) – 忽略。

返回

X (pd.DataFrame or np.ndarray) – 要转换的输入训练数据。形状为 [样本数, 特征数]

返回类型

pd.DataFrame

特征矩阵

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

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

参数

class evalml.pipelines.components.DropColumns(columns=None, random_seed=0, **kwargs)[source]#
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	columns (list(string)) – 列名列表，用于确定要删除哪些列。
needs_fitting	False
training_only	False

方法

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

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

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

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

clone(self)#

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

删除列转换器

参数

fit(self, X, y=None)#
X (pd.DataFrame) – 要检查的数据。

返回

self

y (pd.Series, ignored) – 目标。

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

fit_transform(self, X, y=None)#

从文件路径加载组件。

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

static load(file_path)#: 返回用于初始化组件的参数。

property parameters(self)#

将组件保存到文件路径。

参数

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

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

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

参数

transform(self, X, y=None)[source]#
X (pd.DataFrame) – 要转换的数据。

返回

转换后的 X。

返回类型

pd.DataFrame

y (pd.Series, optional) – 目标。

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

删除具有 NaN 值的行的转换器。

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	True
name	random_seed (int) – 随机数生成器的种子。此组件未使用。默认为 0。
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	删除 NaN 行转换器
`update_parameters`	更新组件的参数字典。

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

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

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

clone(self)#

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

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

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

fit_transform(self, X, y=None)#

从文件路径加载组件。

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

static load(file_path)#

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

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

返回: True。

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

property parameters(self)#

将组件保存到文件路径。

参数

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

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

删除 NaN 行转换器

参数

X (pd.DataFrame) – 特征。
transform(self, X, y=None)[source]#

返回

y (pd.Series, optional) – 目标数据。

返回类型

删除了 NaN 行的数据。

(pd.DataFrame, pd.Series)

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

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

参数

class evalml.pipelines.components.DropNullColumns(pct_null_threshold=1.0, random_seed=0, **kwargs)[source]#
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	pct_null_threshold (float) – 要删除的输入特征中 NaN 值的百分比。必须是介于 [0, 1]（包含）之间的值。如果等于 0.0，将删除包含任何空值的列。如果等于 1.0，将删除包含所有空值的列。默认为 0.95。
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	删除空值列转换器
`update_parameters`	更新组件的参数字典。

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

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

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

clone(self)#

返回此组件的默认参数。

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

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

default_parameters(cls)#

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

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

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

fit_transform(self, X, y=None)#

从文件路径加载组件。

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

static load(file_path)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

删除空值列转换器

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

删除由行索引指定的行的转换器。

参数

indices_to_drop (list) – 要在输入数据中删除的索引列表。默认为 None。
class evalml.pipelines.components.DropNaNRowsTransformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	True
name	丢弃行转换器
training_only	True

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	删除 NaN 行转换器
`update_parameters`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

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

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

删除 NaN 行转换器

参数

X (pd.DataFrame) – 特征。
transform(self, X, y=None)[source]#

返回

行索引已被删除的数据。

返回类型

删除了 NaN 行的数据。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.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”，最小化的损失是跨整个概率分布拟合的多项式损失，即使数据是二分类的。“multinomial”在 solver=”liblinear” 时不可用。“auto”如果数据是二分类的，或者 solver=”liblinear”，则选择“ovr”，否则选择“multinomial”。默认为“auto”。
solver ({"newton-cg", "lbfgs", "liblinear", "sag", "saga"}) –
用于优化问题的算法。对于小型数据集，“liblinear”是一个不错的选择，而“sag”和“saga”对于大型数据集更快。对于多分类问题，只有“newton-cg”、“sag”、“saga”和“lbfgs”处理多项式损失；“liblinear”仅限于一对多方案。
- “newton-cg”、“lbfgs”、“sag”和“saga”处理 L2 或无惩罚
- “liblinear”和“saga”也处理 L1 惩罚
- “saga”也支持“elasticnet”惩罚
- “liblinear”不支持设置 penalty=’none’
默认为“saga”。
n_jobs (int) – 用于运行 xgboost 的并行线程数。请注意，创建线程竞争会显著降低算法速度。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “C”: Real(0.01, 10), “l1_ratio”: Real(0, 1)}
model_family	ModelFamily.LINEAR_MODEL
modifies_features	True
modifies_target	False
name	Elastic Net 分类器
supported_problem_types	[ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`feature_importance`	已拟合的 ElasticNet 分类器的特征重要性。
`fit`	将 ElasticNet 分类器组件拟合到数据。
`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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

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

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	电子邮件特征化器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

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

返回

self

引发

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

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

transform(self, X, y=None)#

转换数据 X。

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

引发

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

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

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

参数

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

属性

model_family	ModelFamily.NONE
modifies_features	True
modifies_target	False
training_only	False

方法

`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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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][源代码]#

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

参数

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

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

返回: True。

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

predict(self, X: pandas.DataFrame) → pandas.Series[源代码]#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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 数据流格式。

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.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 指数平滑预测器。

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

参数

trend (str) – 趋势分量的类型。默认为 None。
damped_trend (bool) – 如果趋势分量应被抑制。默认为 False。
seasonal (str) – 季节分量的类型。取 {“additive”, None} 之一。如果目标数据都不为 0，也可以是乘法类型，
0 (none of the target data is) –
None. (but AutoMLSearch wiill not tune for this. Defaults to) – 但 AutoMLSearch 不会对此进行调优。默认为 None。
sp (int) – 要考虑的季节周期数。默认为 2。
n_jobs (int 或 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 的全零数组，因为指数平滑回归器未定义 feature_importance。
`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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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。

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

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.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。
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(特征数)。
- 如果是“log2”，则 max_features=log2(特征数)。
如果是 None，则 max_features = 特征数。
即使需要有效地检查超过 max_features 个特征，寻找分割也不会停止，直到找到节点样本的至少一个有效划分。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
- 分割内部节点所需的最小样本数
- 如果是 int 类型，则将 min_samples_split 视为最小数量。
2. (Defaults to) – 默认为 2。
默认为 2。
n_jobs (int 或 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	Extra Trees 分类器
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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

Extra Trees 回归器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
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(特征数)。
- 如果是“log2”，则 max_features=log2(特征数)。
如果是 None，则 max_features = 特征数。
即使需要有效地检查超过 max_features 个特征，寻找分割也不会停止，直到找到节点样本的至少一个有效划分。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
- 分割内部节点所需的最小样本数
- 如果是 int 类型，则将 min_samples_split 视为最小数量。
2. (Defaults to) – 默认为 2。
默认为 2。
n_jobs (int 或 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

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

参数

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

属性

modifies_features	True
modifies_target	False
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

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

返回

self

引发

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)[source]#

获取选定特征的名称。

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

static load(file_path)#

从文件路径加载组件。

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

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

引发

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

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

属性

hyperparameter_ranges	{ “categorical_impute_strategy”: [“most_frequent”], “numeric_impute_strategy”: [“mean”, “median”, “most_frequent”, “knn”], “boolean_impute_strategy”: [“most_frequent”]}
modifies_features	True
modifies_target	False
name	Imputer
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将 impute 器拟合到数据。‘None’ 值在 imputation 前转换为 np.nan 并被视为相同。

参数

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

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

K 近邻分类器。

参数

n_neighbors (int) – 默认使用的邻居数量。默认为 5。
weights ({‘uniform’, ‘distance’} or callable) –
预测中使用的权重函数。可以是
- ‘uniform’ : 均匀权重。每个邻域中的所有点权重相等。
- ‘distance’ : 根据距离的倒数加权点。在这种情况下，查询点附近的邻居比远处的邻居影响更大。
- [可调用] : 一个用户自定义函数，接受一个距离数组，并返回一个形状相同的权重数组。
默认为“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 分类器未定义 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

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

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

对标签进行概率估计。

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

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

positive_label (int, str) – 对于二元分类问题，应视为正类 (1) 的标签。对于多类问题则忽略。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。忽略。

属性

hyperparameter_ranges	{}
modifies_features	False
modifies_target	True
name	标签编码器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合标签编码器。

参数

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

返回

self

引发

ValueError – 如果输入 y 为 None。

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

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

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series

inverse_transform(self, y)[source]#

解码目标数据。

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series

引发

ValueError – 如果输入 y 为 None。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

LightGBM 分类器。

参数

boosting_type (string) – 要使用的 Boosting 类型。默认为“gbdt”。- ‘gbdt’ 使用传统梯度提升决策树 - “dart”，使用 Dropouts meet Multiple Additive Regression Trees - “goss”，使用基于梯度的单侧采样 - “rf”，使用随机森林。
learning_rate (float) – Boosting 学习率。默认为 0.1。
n_estimators (int) – 要拟合的 Boosting 树数量。默认为 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

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

返回

self

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

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

predict_proba(self, X)[source]#

使用拟合的 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

LightGBM 回归器。

参数

boosting_type (string) – 要使用的 Boosting 类型。默认为“gbdt”。- ‘gbdt’ 使用传统梯度提升决策树 - “dart”，使用 Dropouts meet Multiple Additive Regression Trees - “goss”，使用基于梯度的单侧采样 - “rf”，使用随机森林。
learning_rate (float) – Boosting 学习率。默认为 0.1。
n_estimators (int) – 要拟合的 Boosting 树数量。默认为 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

将 LightGBM 回归器拟合到数据。

参数

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

返回

self

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

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

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

对标签进行概率估计。

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

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	线性判别分析转换器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合 LDA 组件。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

ValueError – 如果输入数据不全为数字。

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

引发

ValueError – 如果输入数据不全为数字。

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

引发

ValueError – 如果输入数据不全为数字。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

线性回归器。

参数

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

属性

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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

逻辑回归分类器。

参数

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

属性

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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

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

属性

hyperparameter_ranges	{}
modifies_features	False
modifies_target	True
name	对数转换器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合 LogTransformer。

参数

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

返回

self

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

对目标变量进行对数变换。

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series 的元组

inverse_transform(self, y)[source]#

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

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

对目标变量进行对数变换。

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series 的元组

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

用于计算文本输入潜在语义分析值 (LSA) 的转换器。

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	LSA 转换器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合输入数据。

参数

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

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

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

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.MultiseriesTimeSeriesBaselineRegressor(gap=1, forecast_horizon=1, random_seed=0, **kwargs)[source]#

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

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

参数

gap (int) – 预测日期与目标日期之间的间隔，必须是正整数。如果 gap 为 0，目标日期将向前移动 1 个时间周期。默认为 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self)#

决策树分类器

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

返回: 全零数组。
返回类型: np.ndarray (float)

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

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

参数

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

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

参数

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

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

返回: True。

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

predict(self, X)[source]#

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

参数: 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

使用 featuretools 的 nlp_primitives 自动提取文本列特征的转换器。

由于模型无法处理非数字数据，任何文本都必须分解为提供有关该文本有用信息的特征。该组件将每个文本列分解为几个信息丰富的特征：多样性得分、每词平均字符数、极性得分、LSA（潜在语义分析）、字符数和词数。在此组件上调用 transform 将用这些数字列替换给定数据集中的任何文本列。

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	自然语言特征提取器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

将组件拟合到数据。

参数

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

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

一个将分类特征编码为 one-hot 数字数组的转换器。

参数

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	独热编码器
training_only	False

方法

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

categories(self, feature_name)[source]#

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

参数: feature_name (str) – 拟合期间提供给独热编码器的任何特征的名称。
返回: 唯一的类别，与拟合期间提供的 dtype 相同。
返回类型: 与每个特征相关的重要性。
引发: ValueError – 如果该特征未作为训练特征提供给独热编码器。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合独热编码器组件。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

ValueError – 如果编码列失败。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

get_feature_names(self)[source]#

拟合后返回分类特征的特征名。

特征名称的格式为 {column name}_{category name}。如果出现重复名称，将在特征名称末尾添加一个整数以区分。

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

返回: 编码后的特征名称，与 input_features 的顺序相同。
返回类型: 与每个特征相关的重要性。

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

对输入数据进行独热编码。

参数

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

返回

转换后的数据，其中每个分类特征已使用独热编码转换为数值列。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

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

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	序数编码器
training_only	False

方法

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

categories(self, feature_name)[source]#

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

参数: feature_name (str) – 拟合期间提供给序数编码器的任何特征的名称。
返回: 唯一的类别，与拟合期间提供的 dtype 相同。
返回类型: 与每个特征相关的重要性。
引发: ValueError – 如果该特征未作为训练特征提供给序数编码器。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合序数编码器组件。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

ValueError – 如果编码列失败。
TypeError – 如果 features_to_encode 中指定了非序数（Ordinal）列。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

get_feature_names(self)[source]#

拟合后返回序数特征的特征名。

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

返回: 编码后的特征名称，与 input_features 的顺序相同。
返回类型: 与每个特征相关的重要性。

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

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

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

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

属性

hyperparameter_ranges	None
modifies_features	True
modifies_target	True
name	Oversampler
training_only	True

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

对数据拟合过采样器。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

fit_transform(self, X, y)#

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

删除了 NaN 行的数据。

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

返回

转换后的特征和目标。

返回类型

pd.DataFrame, pd.Series

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

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

属性

hyperparameter_ranges	Real(0.25, 1)}:type: {“variance”
modifies_features	True
modifies_target	False
name	PCA 转换器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

拟合 PCA 组件。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

ValueError – 如果输入数据不全为数字。

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

引发

ValueError – 如果输入数据不全为数字。

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

引发

ValueError – 如果输入数据不全为数字。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

参数

impute_strategies (dict) – 列和 {“impute_strategy”: 策略, “fill_value”: 值} 配对。有效的插补策略值包括数值数据的“mean”（均值）、“median”（中位数）、“most_frequent”（众数）、“constant”（常数），以及对象数据类型的“most_frequent”（众数）、“constant”（常数）。默认为 None，对所有列使用“most_frequent”。当 impute_strategy == “constant”时，使用 fill_value 替换缺失数据。当 fill_value 为 None 时，对数值数据使用 0 进行插补，对字符串或对象数据类型使用“missing_value”。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	按列插补器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

对输入数据拟合插补器。

参数

X (pd.DataFrame or np.ndarray) – 要拟合的输入训练数据，形状为 [n_samples, n_features]。
y (pd.Series, optional) – 目标训练数据，长度为 [n_samples]。忽略此参数。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

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

返回

转换后的 X。

返回类型

pd.DataFrame

引发

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

static load(file_path)#

从文件路径加载组件。

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

needs_fitting(self)#

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

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

返回: True。

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

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

将组件保存到文件路径。

参数

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

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

通过插补缺失值来转换输入数据。

参数

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

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

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

使用 scikit-learn 的 PolynomialForecaster 生成目标数据的加法趋势部分。在拟合期间，将对数据进行多项式拟合。

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

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

参数

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

属性

hyperparameter_ranges	{ “degree”: Integer(1, 3)}
invalid_frequencies	[]
modifies_features	False
modifies_target	True
name	多项式分解器
needs_fitting	True
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`determine_periodicity`	使用自相关方法确定季节性信号可能最显着周期的函数。
`fit`	拟合 PolynomialDecomposer 并确定季节性信号。
`fit_transform`	从目标变量中移除拟合的趋势和季节性。
`get_trend_dataframe`	返回包含 4 列的数据框列表：signal（信号）、trend（趋势）、seasonality（季节性）、residual（残差）。
`inverse_transform`	将拟合的趋势和季节性添加回目标变量。
`is_freq_valid`	确定给定的字符串是否表示此分解器的有效频率。
`load`	从文件路径加载组件。
`parameters`	返回用于初始化组件的参数。
`plot_decomposition`	绘制目标信号的分解图。
`save`	将组件保存到文件路径。
`set_period`	根据目标的季节性设置组件季节性周期的函数。
`transform`	通过移除多项式趋势和移动平均季节性来转换目标数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

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

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

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

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

参数

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

返回

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

返回类型

int

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

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

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

参数

X (pd.DataFrame, optional) – 有条件地用于构建日期时间索引。
y (pd.Series) – 要进行去趋势和去季节化的目标变量。

返回

self

引发

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

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

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

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series 的元组

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

返回包含 4 列的数据框列表：signal（信号）、trend（趋势）、seasonality（季节性）、residual（残差）。

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

参数

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

返回

每个 DataFrame 包含列“signal”（信号）、“trend”（趋势）、“seasonality”（季节性）和“residual”（残差），: 后 3 列的值是目标数据的分解元素。“signal”（信号）列只是输入的目标信号，但使用日期时间索引重新索引以匹配输入特征。

返回类型

pd.DataFrame 列表

引发

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

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

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

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

参数

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

返回

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

返回类型

pd.DataFrame, pd.Series 的元组

引发

ValueError – 如果 y 为 None。

classmethod is_freq_valid(cls, freq: str)#

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

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

static load(file_path)#

从文件路径加载组件。

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

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

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

绘制目标信号的分解图。

参数

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

返回

绘制了分解图的图和坐标轴: plot
(多序列) dict[str, (matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes])]：一个字典，将序列 ID: 映射到绘制了分解图的图和坐标轴

返回类型

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

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

将组件保存到文件路径。

参数

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

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

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

参数

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

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

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

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

参数

X (pd.DataFrame, optional) – 有条件地用于构建日期时间索引。
y (pd.Series) – 要进行去趋势和去季节化的目标变量。

返回

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

返回类型

pd.DataFrame, pd.Series 的元组

引发

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

Prophet 是一种基于加法模型的时间序列数据预测方法，其中非线性趋势与年度、每周和每日季节性以及节假日效应相结合。它最适用于具有强季节性效应和数个季节历史数据的时间序列。Prophet 对缺失数据和趋势变化具有鲁棒性，并且通常能很好地处理异常值。

更多信息请参见：https://fbdocs.cn/prophet/

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
changepoint_prior_scale (float) – 确定用于拟合速率变化的稀疏先验的强度。增加此值会增加趋势的灵活性。默认为 0.05。
seasonality_prior_scale (int) – 与 changepoint_prior_scale 类似。调整季节性模型拟合数据的程度。默认为 10。
holidays_prior_scale (int) – 与 changepoint_prior_scale 类似。调整节假日拟合数据的程度。默认为 10。
seasonality_mode (str) – 确定此组件如何拟合季节性。选项包括“additive”（加法）和“multiplicative”（乘法）。默认为“additive”。
stan_backend (str) – 确定用于运行 Prophet 的后端。选项包括“CMDSTANPY”和“PYSTAN”。默认为“CMDSTANPY”。
interval_width (float) – 确定调用 get_prediction_intervals 时预测区间范围的置信度。接受范围为 (0,1) 的值。默认为 0.95。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

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`	返回长度为 1 的全 0 数组，因为 feature_importance 未为 Prophet 回归器定义。
`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[source]#: 构建用于拟合和预测的 Prophet 数据。

clone(self)#

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

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

default_parameters(cls) → dict#

返回此组件的默认参数。

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

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

描述组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

property feature_importance(self) → numpy.ndarray#: 返回长度为 1 的全 0 数组，因为 feature_importance 未为 Prophet 回归器定义。

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

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

参数

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

返回

self

get_params(self) → dict[source]#: 获取 Prophet 回归器的参数。

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

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
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 之前是否需要拟合。

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

返回: True。

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

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

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

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RandomForestClassifier(n_estimators=100, max_depth=6, n_jobs=-1, random_seed=0, **kwargs)[source]#

随机森林分类器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_depth (int) – 基础学习器的最大树深度。默认为 6。
n_jobs (int 或 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

参数

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RandomForestRegressor(n_estimators: int = 100, max_depth: int = 6, n_jobs: int = -1, random_seed: Union[int, float] = 0, **kwargs)[source]#

随机森林回归器。

参数

n_estimators (float) – 森林中的树木数量。默认为 100。
max_depth (int) – 基础学习器的最大树深度。默认为 6。
n_jobs (int 或 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#

决策树分类器

返回: property feature_importance(self) → pandas.Series#
返回类型: 与每个特征相关的重要性。
引发: np.ndarray

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

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

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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

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

返回: True。

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

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

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

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

用与 EvalML 兼容的数据类型替换具有新的可空数据类型的特征的转换器。

属性

hyperparameter_ranges	None
modifies_features	True
modifies_target	{}
name	替换可空类型转换器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	用新的 pandas 可空类型替换数据和目标数据中的非可空类型。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过将包含可空类型的列替换为适当的替换类型来转换数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

fit_transform(self, X, y=None)[source]#

用新的 pandas 可空类型替换数据和目标数据中的非可空类型。

参数

X (pd.DataFrame, optional) – 输入特征。
y (pd.Series) – 目标数据。

返回

设置了非可空类型的输入特征和目标数据。

返回类型

pd.DataFrame, pd.Series 的元组

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过将包含可空类型的列替换为适当的替换类型来转换数据。

可空整数为“float64”，可空布尔值为“category”。

参数

X (pd.DataFrame) – 要转换的数据
y (pd.Series, optional) – 要转换的目标数据

返回

转换后的 X pd.Series：转换后的 y

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RFClassifierRFESelector(step=0.2, min_features_to_select=1, cv=None, scoring=None, n_jobs=-1, n_estimators=10, max_depth=None, random_seed=0, **kwargs)[source]#

使用带有随机森林分类器的递归特征消除来选择相关特征。

参数

step (int, float) – 每次迭代中要消除的特征数量。如果指定整数，则表示要消除的特征数量。如果指定浮点数，则表示每次迭代要消除的特征百分比。最后一次迭代可能会丢弃少于此数量的特征，以满足 min_features_to_select 约束。默认为 0.2。
min_features_to_select (int) – 要返回的最小特征数量。默认为 1。
cv (int or None) – 用于交叉验证拆分策略的折叠次数。默认为 None，此时将使用 5 个折叠。
scoring (str, callable or None) – 用于指定评分方法的字符串或可调用评分器对象。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
n_estimators (int) – 森林中的树数量。默认为 10。
max_depth (int) – 基本学习器的最大树深度。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “step”: Real(0.05, 0.25)}
modifies_features	True
modifies_target	False
name	带有 RF 分类器的 RFE 选择器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取选定特征的名称。

返回: 选定特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或未实现 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RFClassifierSelectFromModel(number_features=None, n_estimators=10, max_depth=None, percent_features=0.5, threshold='median', n_jobs=-1, random_seed=0, **kwargs)[source]#

使用随机森林分类器根据重要性权重选择最重要的特征。

参数

number_features (int) – 要选择的最大特征数量。如果同时指定了 percent_features 和 number_features，则取特征数量较大的那个。默认为 None。
n_estimators (int) – 森林中的树数量。默认为 10。
max_depth (int) – 基本学习器的最大树深度。默认为 None。
percent_features (float) – 要使用的特征百分比。如果同时指定了 percent_features 和 number_features，则取特征数量较大的那个。默认为 0.5。
threshold (string or float) – 用于特征选择的阈值。重要性大于或等于此阈值的特征被保留，其余的被丢弃。如果为“median”，则阈值为特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
modifies_features	True
modifies_target	False
name	RF 分类器从模型中选择
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取选定特征的名称。

返回: 选定特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或未实现 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RFRegressorRFESelector(step=0.2, min_features_to_select=1, cv=None, scoring=None, n_jobs=-1, n_estimators=10, max_depth=None, random_seed=0, **kwargs)[source]#

使用带有随机森林回归器的递归特征消除来选择相关特征。

参数

step (int, float) – 每次迭代中要消除的特征数量。如果指定整数，则表示要消除的特征数量。如果指定浮点数，则表示每次迭代要消除的特征百分比。最后一次迭代可能会丢弃少于此数量的特征，以满足 min_features_to_select 约束。默认为 0.2。
min_features_to_select (int) – 要返回的最小特征数量。默认为 1。
cv (int or None) – 用于交叉验证拆分策略的折叠次数。默认为 None，此时将使用 5 个折叠。
scoring (str, callable or None) – 用于指定评分方法的字符串或可调用评分器对象。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
n_estimators (int) – 森林中的树数量。默认为 10。
max_depth (int) – 基本学习器的最大树深度。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “step”: Real(0.05, 0.25)}
modifies_features	True
modifies_target	False
name	带有 RF 回归器的 RFE 选择器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取选定特征的名称。

返回: 选定特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或未实现 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.RFRegressorSelectFromModel(number_features=None, n_estimators=10, max_depth=None, percent_features=0.5, threshold='median', n_jobs=-1, random_seed=0, **kwargs)[source]#

使用随机森林回归器根据重要性权重选择最重要的特征。

参数

number_features (int) – 要选择的最大特征数量。如果同时指定了 percent_features 和 number_features，则取特征数量较大的那个。默认为 0.5。
n_estimators (int) – 森林中的树数量。默认为 10。
max_depth (int) – 基本学习器的最大树深度。默认为 None。
percent_features (float) – 要使用的特征百分比。如果同时指定了 percent_features 和 number_features，则取特征数量较大的那个。默认为 0.5。
threshold (string or float) – 用于特征选择的阈值。重要性大于或等于此阈值的特征被保留，其余的被丢弃。如果为“median”，则阈值为特征重要性的中位数。也可以使用缩放因子（例如，“1.25*mean”）。默认为 median。
n_jobs (int 或 None) – 并行运行的作业数。-1 表示使用所有进程。默认为 -1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “percent_features”: Real(0.01, 1), “threshold”: [“mean”, “median”],}
modifies_features	True
modifies_target	False
name	RF 回归器从模型中选择
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	使用特征选择器拟合和转换数据。
`get_names`	获取选定特征的名称。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)#

使用特征选择器拟合和转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_names(self)#

获取选定特征的名称。

返回: 选定特征名称的列表。
返回类型: list[str]

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

通过选择特征来转换输入数据。如果 component_obj 没有 transform 方法，将引发 MethodPropertyNotFoundError 异常。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 目标数据。忽略。

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果特征选择器没有 transform 方法或未实现 transform 的 component_obj

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.SelectByType(column_types=None, exclude=False, random_seed=0, **kwargs)[source]#

根据输入数据中指定的 Woodwork 逻辑类型或语义标签选择列。

参数

column_types (string, ww.LogicalType, list(string), list(ww.LogicalType)) – Woodwork 类型或标签列表，用于确定要选择或排除哪些列。
exclude (bool) – 如果为 True，则排除 column_types 而不是包含它们。默认为 False。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	按类型选择列转换器
needs_fitting	False
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	删除列转换器
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过选择列来转换数据 X。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

删除列转换器

参数

fit(self, X, y=None)#
X (pd.DataFrame) – 要检查的数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过选择列来转换数据 X。

参数

transform(self, X, y=None)[source]#
X (pd.DataFrame) – 要转换的数据。

返回

转换后的 X。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.SelectColumns(columns=None, random_seed=0, **kwargs)[source]#

选择输入数据中指定的列。

参数

columns (list(string)) – 列名列表，用于确定要选择哪些列。如果列不存在，则不会被选择。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	选择列转换器
needs_fitting	False
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	删除列转换器
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	使用拟合的列选择器组件转换数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

删除列转换器

参数

fit(self, X, y=None)#
X (pd.DataFrame) – 要转换的数据。

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

使用拟合的列选择器组件转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.SimpleImputer(impute_strategy='most_frequent', fill_value=None, random_seed=0, **kwargs)[source]#

根据指定的填补策略填补缺失数据。忽略自然语言列。

参数

impute_strategy (string) – 要使用的填充策略。有效值包括数值数据的“mean”、“median”、“most_frequent”、“constant”，以及对象数据类型的“most_frequent”、“constant”。
fill_value (string) – 当 impute_strategy == “constant” 时，fill_value 用于替换缺失数据。对数值数据填充时默认为 0，对字符串或对象数据类型填充时默认为“missing_value”。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “impute_strategy”: [“mean”, “median”, “most_frequent”]}
modifies_features	True
modifies_target	False
name	简单填充器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将 impute 器拟合到数据。'None' 值在 imputation 前转换为 np.nan 并被视为相同。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过填充缺失值来转换输入。'None' 和 np.nan 值被视为相同。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将 impute 器拟合到数据。‘None’ 值在 imputation 前转换为 np.nan 并被视为相同。

参数

X (pd.DataFrame or np.ndarray) – 输入训练数据，形状为 [n_samples, n_features]
y (pd.Series, optional) – 目标训练数据，长度为 [n_samples]

返回

self

引发

ValueError – 如果 SimpleImputer 接收到的数据框同时包含布尔和分类数据。

fit_transform(self, X, y=None)[source]#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据
transform(self, X, y=None)[source]#

返回

转换后的 X

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过填充缺失值来转换输入。‘None’ 和 np.nan 值被视为相同。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 忽略。

返回

转换后的 X

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.StackedEnsembleBase(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

Stacked Ensemble 基类。

参数

final_estimator (Estimator or subclass) – 用于组合基本估计器的估计器。
n_jobs (int or None) – 描述流水线并行级别的整数。None 和 1 是等效的。如果设置为 -1，则使用所有 CPU。对于大于 -1 的 n_jobs，使用 (n_cpus + 1 + n_jobs) 个 CPU。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果出现这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

model_family	ModelFamily.ENSEMBLE
modifies_features	True
modifies_target	False
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回堆叠集成类的默认参数。
`describe`	描述组件及其参数。
`feature_importance`	未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。
`fit`	返回与每个特征相关的重要性。
`get_prediction_intervals`	使用拟合的回归器查找预测区间。
`load`	从文件路径加载组件。
`name`	返回此组件的字符串名称。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`predict`	将估计器拟合到数据。
`predict_proba`	对标签进行概率估计。
`save`	将组件保存到文件路径。
`supported_problem_types`	此估计器支持的问题类型。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回堆叠集成类的默认参数。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#: 未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回与每个特征相关的重要性。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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]#

使用拟合的回归器查找预测区间。

参数

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 name(cls)#: 返回此组件的字符串名称。

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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 数据流格式。

property supported_problem_types(cls)#: 此估计器支持的问题类型。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.StackedEnsembleClassifier(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

Stacked Ensemble 分类器。

参数

final_estimator (Estimator or subclass) – 用于组合基本估计器的分类器。如果为 None，则使用 ElasticNetClassifier。
n_jobs (int or None) – 描述流水线并行级别的整数。None 和 1 是等效的。如果设置为 -1，则使用所有 CPU。对于小于 -1 的 n_jobs，使用 (n_cpus + 1 + n_jobs) 个 CPU。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果出现这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> from evalml.pipelines.component_graph import ComponentGraph
>>> from evalml.pipelines.components.estimators.classifiers.decision_tree_classifier import DecisionTreeClassifier
>>> from evalml.pipelines.components.estimators.classifiers.elasticnet_classifier import ElasticNetClassifier
...
>>> component_graph = {
...     "Decision Tree": [DecisionTreeClassifier(random_seed=3), "X", "y"],
...     "Decision Tree B": [DecisionTreeClassifier(random_seed=4), "X", "y"],
...     "Stacked Ensemble": [
...         StackedEnsembleClassifier(n_jobs=1, final_estimator=DecisionTreeClassifier()),
...         "Decision Tree.x",
...         "Decision Tree B.x",
...         "y",
...     ],
... }
...
>>> cg = ComponentGraph(component_graph)
>>> assert cg.default_parameters == {
...     'Decision Tree Classifier': {'criterion': 'gini',
...                                  'max_features': 'sqrt',
...                                  'max_depth': 6,
...                                  'min_samples_split': 2,
...                                  'min_weight_fraction_leaf': 0.0},
...     'Stacked Ensemble Classifier': {'final_estimator': ElasticNetClassifier,
...                                     'n_jobs': -1}}

属性

hyperparameter_ranges	{}
model_family	ModelFamily.ENSEMBLE
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`	未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。
`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)#

返回堆叠集成类的默认参数。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#: 未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回与每个特征相关的重要性。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.StackedEnsembleRegressor(final_estimator=None, n_jobs=-1, random_seed=0, **kwargs)[source]#

Stacked Ensemble 回归器。

参数

final_estimator (Estimator or subclass) – 用于组合基本估计器的回归器。如果为 None，则使用 ElasticNetRegressor。
n_jobs (int or None) – 描述流水线并行级别的整数。None 和 1 是等效的。如果设置为 -1，则使用所有 CPU。对于大于 -1 的 n_jobs，使用 (n_cpus + 1 + n_jobs) 个 CPU。默认为 -1。- 注意：对于 n_jobs != 1 的值，可能会抛出一些多进程错误。如果出现这种情况，请使用 n_jobs = 1。
random_seed (int) – 随机数生成器的种子。默认为 0。

示例

>>> from evalml.pipelines.component_graph import ComponentGraph
>>> from evalml.pipelines.components.estimators.regressors.rf_regressor import RandomForestRegressor
>>> from evalml.pipelines.components.estimators.regressors.elasticnet_regressor import ElasticNetRegressor
...
>>> component_graph = {
...     "Random Forest": [RandomForestRegressor(random_seed=3), "X", "y"],
...     "Random Forest B": [RandomForestRegressor(random_seed=4), "X", "y"],
...     "Stacked Ensemble": [
...         StackedEnsembleRegressor(n_jobs=1, final_estimator=RandomForestRegressor()),
...         "Random Forest.x",
...         "Random Forest B.x",
...         "y",
...     ],
... }
...
>>> cg = ComponentGraph(component_graph)
>>> assert cg.default_parameters == {
...     'Random Forest Regressor': {'n_estimators': 100,
...                                 'max_depth': 6,
...                                 'n_jobs': -1},
...     'Stacked Ensemble Regressor': {'final_estimator': ElasticNetRegressor,
...                                    'n_jobs': -1}}

属性

hyperparameter_ranges	{}
model_family	ModelFamily.ENSEMBLE
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`	未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。
`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)#

返回堆叠集成类的默认参数。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#: 未在 StackedEnsembleClassifier 和 StackedEnsembleRegressor 中实现。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回与每个特征相关的重要性。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.StandardScaler(random_seed=0, **kwargs)[source]#

一个通过去除均值并缩放到单位方差来标准化输入特征的转换器。

参数: random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	标准缩放器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	根据给定数据拟合标准缩放器。
`fit_transform`	使用标准缩放器组件拟合并转换数据。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	使用拟合好的标准缩放器转换数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

根据给定数据拟合标准缩放器。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

fit_transform(self, X, y=None)[source]#

使用标准缩放器组件拟合并转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用拟合好的标准缩放器转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.STLDecomposer(time_index: str = None, series_id: str = None, degree: int = 1, period: int = None, periods: dict = None, seasonal_smoother: int = 7, random_seed: int = 0, **kwargs)[source]#

使用 STL 算法去除时间序列中的趋势和季节性。

https://statsmodels.cn/dev/generated/statsmodels.tsa.seasonal.STL.html

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
series_id (str) – 指定 X 中提供多序列 series_id 对象的列名。默认为 None。
degree (int) – 当前未使用。STL 有 3 个类似“次数”的值。目前无法设置。默认为 1。
period (int) – 时间序列数据中对应于循环信号一个周期的条目数。例如，如果已知数据具有每周季节性信号，并且数据是每日数据，则周期可能应为 7。对于具有年度季节性信号的每日数据，周期可能应为 365。如果为 None，statsmodels 将根据频率推断周期。默认为 None。
seasonal_smoother (int) – 底层 STL 算法使用的季节平滑器长度。为兼容性考虑，必须为奇数。如果提供偶数，将使用下一个更高的奇数。默认为 7。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	None
invalid_frequencies	[]
modifies_features	False
modifies_target	True
name	STL 分解器
needs_fitting	True
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`determine_periodicity`	使用自相关方法确定季节性信号可能最显着周期的函数。
`fit`	拟合 STL 分解器并确定季节性信号。
`fit_transform`	从目标变量中移除拟合的趋势和季节性。
`get_trend_dataframe`	返回包含 4 列的数据框列表：signal（信号）、trend（趋势）、seasonality（季节性）、residual（残差）。
`获取趋势预测区间`	计算趋势数据的预测区间。
`inverse_transform`	将拟合的趋势和季节性添加回目标变量。
`is_freq_valid`	确定给定的字符串是否表示此分解器的有效频率。
`load`	从文件路径加载组件。
`parameters`	返回用于初始化组件的参数。
`plot_decomposition`	绘制目标信号的分解图。
`save`	将组件保存到文件路径。
`set_period`	根据目标的季节性设置组件季节性周期的函数。
`transform`	通过移除 STL 趋势和季节性来转换目标数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

classmethod determine_periodicity(cls, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

使用自相关方法确定季节性信号可能最显着周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于该阈值的任何值都被视为 0，并且不会被考虑用于确定周期。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

返回

时间序列数据中目标数据季节性部分重复的条目整数数量。: 如果时间序列数据是每日数据，则这是目标季节性信号重复的天数。注意：目标数据可以包含多个季节性信号。此函数仅返回更强的那个。例如，如果目标数据同时具有每周和每年季节性，函数可能会返回“7”或“365”，具体取决于哪个季节性自相关性更强。如果未检测到周期，则返回 None。

返回类型

int

fit(self, X: pandas.DataFrame, y: Union[pandas.Series, pandas.DataFrame] = None) → STLDecomposer[source]#

拟合 STL 分解器并确定季节性信号。

使用组件存储的参数实例化 statsmodels STL 分解对象并拟合它。由于 statsmodels 对象不符合 sklearn API，它不会在 __init__() 的 _component_obj 中保存，并且每次调用 fit 时都会重新实例化。

为了模拟 sklearn API，拟合 STL 分解器时，会保存完整的季节性分量、季节性分量的一个周期样本、完整的趋势-周期分量以及残差。

y(t) = S(t) + T(t) + R(t)

参数

X (pd.DataFrame, optional) – 有条件地用于构建日期时间索引。
y (pd.Series or pd.DataFrame) – 要去趋势和去季节化的目标变量。

返回

self

引发

ValueError – 如果 y 为 None。
ValueError – 如果目标数据没有 DatetimeIndex 并且特征数据中没有 Datetime 特征

fit_transform(self, X: pandas.DataFrame, y: pandas.Series = None) → tuple[pandas.DataFrame, pandas.Series]#

从目标变量中移除拟合的趋势和季节性。

参数

X (pd.DataFrame, optional) – 被忽略。
y (pd.Series) – 要进行去趋势和去季节化的目标变量。

返回

第一个元素是返回的未经修改的输入特征。: 第二个元素是移除了拟合趋势的目标变量 y。

返回类型

pd.DataFrame, pd.Series 的元组

get_trend_dataframe(self, X, y)[source]#

返回包含 4 列的数据框列表：signal（信号）、trend（趋势）、seasonality（季节性）、residual（残差）。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series or pd.DataFrame) – 作为 Series 提供的单变量问题目标变量数据，或作为 DataFrame 提供的多变量问题目标变量数据。

返回

每个 DataFrame 包含列“signal”（信号）、“trend”（趋势）、“seasonality”（季节性）和“residual”（残差），: 后 3 列的值是目标数据的分解元素。“signal”（信号）列只是输入的目标信号，但使用日期时间索引重新索引以匹配输入特征。

(多序列) 列表字典：序列 ID 映射到 pd.DataFrame 列表，每个 DataFrame 包含“signal”、“trend”、“seasonality”和“residual”列。

返回类型

(单序列) pd.DataFrame 列表

引发

TypeError – 如果 X 的索引中没有时间序列数据。
ValueError – 如果 X 的时间序列索引没有推断的频率。
ValueError – 如果与去趋势器关联的预测器尚未拟合。
TypeError – 如果 y 未作为 pandas Series 或 DataFrame 提供。

get_trend_prediction_intervals(self, y, coverage=None)[source]#

计算趋势数据的预测区间。

参数

y (pd.Series or pd.DataFrame) – 目标数据。
coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。

返回

预测区间，键的格式为 {coverage}_lower 或 {coverage}_upper。(多序列) pd.Series 字典的字典：每个序列 ID 映射到一个预测区间字典。

返回类型

(单序列) pd.Series 字典

inverse_transform(self, y_t: Union[pandas.Series, pandas.DataFrame]) → Union[pandas.Series, pandas.DataFrame][source]#

将拟合的趋势和季节性添加回目标变量。

STL 趋势被预测以覆盖整个请求的目标范围，然后被加回信号中。接着，季节性被向前预测并加回信号中。

参数: y_t (pd.Series or pd.DataFrame) – 目标变量。
返回: 目标变量 y，已将趋势和季节性加回。
返回类型: pd.Series 或 pd.DataFrame
引发: ValueError – 如果 y 为 None。

classmethod is_freq_valid(cls, freq: str)#

确定给定的字符串是否表示此分解器的有效频率。

参数: freq (str) – 要验证的频率。有关选项，请参阅 pandas 文档：https://pandas.ac.cn/pandas-docs/stable/user_guide/timeseries.html#offset-aliases。
返回: 布尔值，表示频率是否有效。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

绘制目标信号的分解图。

参数

X (pd.DataFrame) – 索引中包含时间序列数据的输入数据。
y (pd.Series or pd.DataFrame) – 作为 Series 提供的单变量问题目标变量数据，或作为 DataFrame 提供的多变量问题目标变量数据。
show (bool) – 是否显示绘图。默认为 False。

返回

绘制了分解图的图和坐标轴: plot
(多序列) dict[str, (matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes])]：一个字典，将序列 ID: 映射到绘制了分解图的图和坐标轴

返回类型

(单序列) matplotlib.pyplot.Figure, list[matplotlib.pyplot.Axes]

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

set_period(self, X: pandas.DataFrame, y: pandas.Series, acf_threshold: float = 0.01, rel_max_order: int = 5)#

根据目标的季节性设置组件季节性周期的函数。

参数

X (pandas.DataFrame) – 时间序列问题的特征数据。
y (pandas.Series) – 时间序列问题的目标数据。
acf_threshold (float) – 用于确定周期的自相关函数阈值。低于该阈值的任何值都被视为 0，并且不会被考虑用于确定周期。默认为 0.01。
rel_max_order (int) – 用于确定周期的相对最大值阶数。默认为 5。

transform(self, X: pandas.DataFrame, y: Union[pandas.Series, pandas.DataFrame] = None) → Union[tuple[pandas.DataFrame, pandas.Series], tuple[pandas.DataFrame, pandas.DataFrame]][source]#

通过移除 STL 趋势和季节性来转换目标数据。

使用 ARIMA 模型向前预测加性趋势并移除它。然后，利用 .fit() 函数确定的第一个周期的季节性数据来外推要转换数据的季节性信号。该季节性信号也被假定为加性的并被移除。

参数

X (pd.DataFrame, optional) – 有条件地用于构建日期时间索引。
y (pd.Series or pd.DataFrame) – 要去趋势和去季节化的目标变量。

返回

输入的特征列表返回时不做修改。目标...: 变量 y 已去趋势和去季节化。
(多序列) pd.DataFrame, pd.DataFrame: 输入的特征列表返回时不做修改。目标...: 变量 y 已去趋势和去季节化。

返回类型

(单序列) pd.DataFrame, pd.Series

引发

ValueError – 如果目标数据没有 DatetimeIndex 并且特征数据中没有 Datetime 特征

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.SVMClassifier(C=1.0, kernel='rbf', gamma='auto', probability=True, random_seed=0, **kwargs)[source]#

支持向量机分类器。

参数

C (float) – 正则化参数。正则化强度与 C 成反比。必须严格大于 0。惩罚项为平方 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	模型家族.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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#

特征重要性仅适用于线性核函数。

如果核函数不是线性的，我们返回一个全零的 numpy 数组。

返回: 拟合好的 SVM 分类器的特征重要性，如果核函数不是线性的，则为全零的 numpy 数组。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回与每个特征相关的重要性。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.SVMRegressor(C=1.0, kernel='rbf', gamma='auto', random_seed=0, **kwargs)[source]#

支持向量机回归器。

参数

C (float) – 正则化参数。正则化强度与 C 成反比。必须严格大于 0。惩罚项为平方 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	模型家族.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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 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]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

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]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series#

将估计器拟合到数据。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: predict(self, X: pandas.DataFrame) → pandas.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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TargetEncoder(cols=None, smoothing=1, handle_unknown='value', handle_missing='value', random_seed=0, **kwargs)[source]#

一个将分类特征编码为目标编码的转换器。

参数

cols (list) – 要编码的列。如果为 None，则编码所有字符串列，否则仅编码提供的列。默认为 None
smoothing (float) – 要应用的平滑因子。该值越大，预期目标值对最终目标编码的影响越大。必须严格大于 0。默认为 1.0
handle_unknown (string) – 确定如何处理遇到的未知类别特征。选项包括“value”、“error”和“return_nan”。默认为“value”，替换为目标均值
handle_missing (string) – 确定如何处理在 fit 或 transform 期间遇到的缺失值。选项包括“value”、“error”和“return_nan”。默认为“value”，替换为目标均值
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	目标编码器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	拟合目标编码器。
`fit_transform`	使用目标编码器拟合并转换数据。
`get_feature_names`	返回拟合后输入特征的特征名称。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	使用拟合好的目标编码器转换数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

拟合目标编码器。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

fit_transform(self, X, y)[source]#

使用目标编码器拟合并转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

get_feature_names(self)[source]#

返回拟合后输入特征的特征名称。

返回: 编码后的特征名称。
返回类型: np.array

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

使用拟合好的目标编码器转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TargetImputer(impute_strategy='most_frequent', fill_value=None, random_seed=0, **kwargs)[source]#

根据指定的填补策略填补缺失目标数据。

参数

impute_strategy (string) – 要使用的插补策略。有效值包括数值数据的“mean”、“median”、“most_frequent”、“constant”，以及对象数据类型的“most_frequent”、“constant”。默认为“most_frequent”。
fill_value (string) – 当 impute_strategy == “constant” 时，fill_value 用于替换缺失数据。默认为 None，用于插补数值数据时使用 0，对于字符串或对象数据类型使用“missing_value”。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “impute_strategy”: [“mean”, “median”, “most_frequent”]}
modifies_features	False
modifies_target	True
name	目标插补器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将插补器拟合到目标数据。“None” 值在插补前转换为 np.nan 并被视为相同。
`fit_transform`	拟合并转换输入目标数据。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过插补缺失值来转换输入目标数据。“None” 和 np.nan 值被视为相同。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)[source]#

将插补器拟合到目标数据。“None” 值在插补前转换为 np.nan 并被视为相同。

参数

X (pd.DataFrame or np.ndarray) – 输入训练数据，形状为 [n_samples, n_features]。忽略。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

TypeError – 如果目标全部填充为 null 值。

fit_transform(self, X, y)[source]#

拟合并转换输入目标数据。

参数

X (pd.DataFrame) – 特征。忽略。
y (pd.Series) – 要插补的目标数据。

返回

原始 X，转换后的 y

返回类型

删除了 NaN 行的数据。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y)[source]#

转换输入目标数据，通过填充缺失值。'None' 和 np.nan 值被视为相同。

参数

X (pd.DataFrame) – 特征。忽略。
y (pd.Series) – 要插补的目标数据。

返回

原始 X，转换后的 y

返回类型

删除了 NaN 行的数据。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TimeSeriesBaselineEstimator(gap=1, forecast_horizon=1, random_seed=0, **kwargs)[source]#

使用朴素预测方法进行预测的时间序列估计器。

对于时间序列问题来说，这是一个有用的简单基线估计器。

参数

gap (int) – 预测日期与目标日期之间的间隔，必须是正整数。如果 gap 为 0，目标日期将向前移动 1 个时间周期。默认为 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#

决策树分类器

由于基线估计器不使用输入特征来计算预测，因此返回一个全零数组。

返回: 全零数组。
返回类型: np.ndarray (float)

fit(self, X, y=None)[source]#

将时间序列基线估计器拟合到数据。

参数

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]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X)[source]#

使用已拟合的时间序列基线估计器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series
引发: ValueError – 如果输入 y 为 None。

predict_proba(self, X)[source]#

使用已拟合的时间序列基线估计器进行概率预测。

参数: 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TimeSeriesFeaturizer(time_index=None, max_delay=2, gap=0, forecast_horizon=1, conf_level=0.05, rolling_window_size=0.25, delay_features=True, delay_target=True, random_seed=0, **kwargs)[source]#

对时间序列问题的输入特征和目标变量进行延迟的转换器。

此组件使用一种基于目标变量自相关值的算法来确定从所有可能的滞后中选择哪些滞后。

该算法基于自相关函数的局部最大值表示对当前时间影响最大的滞后的思想。

该算法计算自相关值，并找到在给定 conf_level 下显著的局部最大值，称为“峰”。由于范围 [0, 10] 内的滞后通常具有预测性但不是局部最大值，因此将峰值与范围 [0, 10] 内的显著滞后取并集。最后，只使用范围 [0, max_delay] 内的选定滞后。

通过 conf_level 参数化算法，AutoMLAlgorithm 可以调整所选择的滞后集合，从而提高找到良好滞后集合的机会。

使用 conf_level 值 1 将选择所有可能的滞后。

参数

time_index (str) – 包含用于数据排序的日期时间信息的列名。忽略。
max_delay (int) – 每个特征的最大滞后时间单位数。默认为 2。
forecast_horizon (int) – 流水线预计预测的时间段数。
conf_level (float) – 范围 (0, 1] 中的浮点数，用于确定从 [1, max_delay] 集合中选择计算哪些滞后的置信区间大小。滞后 1 将始终计算。如果为 1，则选择 [1, max_delay] 集合中（包括）所有可能的滞后。
rolling_window_size (float) – 范围 (0, 1] 中的浮点数，用于确定滚动特征使用的窗口大小。大小计算为 rolling_window_size * max_delay。
delay_features (bool) – 是否滞后输入特征。默认为 True。
delay_target (bool) – 是否滞后目标变量。默认为 True。
gap (int) – 特征收集时间和目标收集时间之间的时间单位数。例如，如果您正在预测下一个时间步的目标，则 gap=1。这仅在 gap=0 时才需要，因为我们需要确保目标变量的滞后从 1 开始。默认为 1。
random_seed (int) – 随机数生成器的种子。此转换器的性能与提供的随机种子无关。

属性

df_colname_prefix	{}_delay_{}
hyperparameter_ranges	Real(0.001, 1.0), “rolling_window_size”: Real(0.001, 1.0)}:type: {“conf_level”
modifies_features	True
modifies_target	False
name	时间序列特征化器
needs_fitting	True
target_colname_prefix	target_delay_{}
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	拟合 DelayFeatureTransformer。
`fit_transform`	拟合组件并转换输入数据。
`load`	从文件路径加载组件。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	计算 X 和 y 的滞后值和滚动均值。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 DelayFeatureTransformer。

参数

X (pd.DataFrame or np.ndarray) – 形状为 [n_samples, n_features] 的输入训练数据
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

ValueError – 如果 self.time_index 为 None

fit_transform(self, X, y=None)[source]#

拟合组件并转换输入数据。

参数

transform(self, X, y=None)[source]#
y (pd.Series, or None) – 目标变量。

返回

转换后的 X。

返回类型

pd.DataFrame

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

计算 X 和 y 的滞后值和滚动均值。

所选的滞后由目标变量的自相关函数确定。有关如何选择滞后的更多信息，请参阅类的文档字符串。如果 y 为 None，则选择所有可能的滞后。

如果 y 不为 None，它还将计算目标变量的滞后值。

如果 y 是数值型的，还将返回 X 和 y 中所有数值特征的滚动均值。

参数

X (pd.DataFrame or None) – 要转换的数据。仅使用目标变量时，预期为 None。
y (pd.Series, or None) – 目标变量。

返回

转换后的 X。不返回原始特征。

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TimeSeriesImputer(categorical_impute_strategy='forwards_fill', numeric_impute_strategy='interpolate', target_impute_strategy='forwards_fill', random_seed=0, **kwargs)[source]#

根据指定的时间序列特定填补策略填补缺失数据。

此转换器应在 TimeSeriesRegularizer 之后使用，以便填充添加到 X 和 y（如果已传递）中的缺失值。

参数

categorical_impute_strategy (string) – 用于字符串、对象、布尔、分类数据类型的填充策略。有效值包括 “backwards_fill” 和 “forwards_fill”。默认为 “forwards_fill”。
numeric_impute_strategy (string) – 用于数值列的填充策略。有效值包括 “backwards_fill”、“forwards_fill” 和 “interpolate”。默认为 “interpolate”。
target_impute_strategy (string) – 用于目标列的填充策略。有效值包括 “backwards_fill”、“forwards_fill” 和 “interpolate”。默认为 “forwards_fill”。
random_seed (int) – 随机数生成器的种子。默认为 0。

引发

ValueError – 如果 categorical_impute_strategy、numeric_impute_strategy 或 target_impute_strategy 不是有效值之一。

属性

hyperparameter_ranges	{ “categorical_impute_strategy”: [“backwards_fill”, “forwards_fill”], “numeric_impute_strategy”: [“backwards_fill”, “forwards_fill”, “interpolate”], “target_impute_strategy”: [“backwards_fill”, “forwards_fill”, “interpolate”],}
modifies_features	True
modifies_target	True
name	时间序列填充器
training_only	True

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将填充器拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过使用指定的时间序列特定策略填充缺失值来转换数据 X。在填充之前，'None' 值被转换为 np.nan，并被视为相同。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

将填充器拟合到数据。

在填充之前，'None' 值被转换为 np.nan，并被视为相同。如果列的开头或结尾缺少值，则该值将分别使用后向填充或前向填充进行填充。

参数

X (pd.DataFrame, np.ndarray) – 输入训练数据，形状为 [n_samples, n_features]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过使用指定的时间序列特定策略填充缺失值来转换数据 X。在填充之前，'None' 值被转换为 np.nan，并被视为相同。

参数

transform(self, X, y=None)[source]#
y (pd.Series, optional) – 可选的，要转换的目标数据。

返回

转换后的 X 和 y

返回类型

pd.DataFrame

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.TimeSeriesRegularizer(time_index=None, frequency_payload=None, window_length=4, threshold=0.4, random_seed=0, **kwargs)[source]#

对间隔不一致的日期时间列进行正则化的转换器。

如果将 X 传递给 fit/transform 方法，将检查 time_index 列是否存在可推断的偏移频率。如果 time_index 列是完全可推断的，则此转换器将不执行任何操作并返回原始的 X 和 y。

如果 X 没有完全可推断的频率但可以估计频率，则将根据 time_index 的估计频率重新格式化 X 和 y。在原始传递的 X 和 y 中：- 将添加缺失的日期时间值，并将其在 X 和 y 中对应的列设置为 None。- 将删除重复的日期时间值。- 将删除额外的日期时间值。- 如果可以确定重复或额外的值未对齐，则将其重新定位以替代缺失值。

此转换器应在 TimeSeriesImputer 之前使用，以便填充添加到 X 和 y（如果已传递）中的缺失值。

如果用于多系列数据集，则特别适用于未堆叠的数据集。

参数

time_index (string) – 包含用于排序数据的日期时间信息的列的名称，必需。默认为 None。
frequency_payload (tuple) – 从 Woodwork 的 infer_frequency 函数返回的 payload，其中 debug 为 True。默认为 None。
window_length (int) – 用于进行推断的滚动窗口大小，以确定不可推断频率的普遍性。
5. (较低的值使此组件对识别大量错误的日期时间值更敏感。默认为)
threshold (float) – 需要能够推断频率的窗口的最小百分比。较低的值使此组件更
0.8. (对识别大量错误的日期时间值敏感。默认为)
random_seed (int) – 随机数生成器的种子。此转换器的性能与提供的随机种子无关。
0. (默认为)

引发

ValueError – 如果 frequency_payload 参数未传递元组

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	True
name	时间序列规范化器
training_only	True

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	拟合 TimeSeriesRegularizer。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	将数据框和目标数据规范化为可推断的偏移频率。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)[source]#

拟合 TimeSeriesRegularizer。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

引发

ValueError – 如果 self.time_index 为 None，如果 X 和 y 长度不同，如果在 X 中的 time_index 没有可估计的偏移频率
TypeError – 如果 time_index 列不是 Datetime 类型
KeyError – 如果 time_index 列不存在

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

将数据框和目标数据规范化为可推断的偏移频率。

根据可推断的偏移频率创建“干净”的 X 和 y（如果传递了 y），并将与原始 X 和 y 匹配的日期时间值填充到干净的 X 和 y 中。识别为未对齐的日期时间值将移动到其适当的位置。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

具有可推断 time_index 偏移频率的数据。

返回类型

删除了 NaN 行的数据。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.Transformer(parameters=None, component_obj=None, random_seed=0, **kwargs)[source]#

可能需要或不需要拟合来转换数据的组件。这些组件在估计器之前使用。

要实现新的 Transformer，请定义您自己的类，它是 Transformer 的子类，包括一个名称以及在 AutoML 搜索（超参数）期间要调整的任何参数的可接受范围列表。定义一个 __init__ 方法，该方法设置任何必要的状态和对象。确保您的 __init__ 仅使用标准关键字参数，并使用参数字典调用 super().__init__()。如果适用，您还可以重写此类中的 fit、transform、fit_transform 和其他方法。

要查看一些示例，请查阅任何 Transformer 组件的定义。

参数

parameters (dict) – 组件的参数字典。默认为 None。
component_obj (obj) – 在组件实现中有用的第三方对象。默认为 None。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

modifies_features	True
modifies_target	False
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`name`	返回此组件的字符串名称。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	转换数据 X。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)[source]#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

property name(cls)#: 返回此组件的字符串名称。

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

abstract transform(self, X, y=None)[source]#

转换数据 X。

参数

transform(self, X, y=None)[source]#
transform(self, X, y=None)[source]#

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.Undersampler(sampling_ratio=0.25, sampling_ratio_dict=None, min_samples=100, min_percentage=0.1, random_seed=0, **kwargs)[source]#

初始化一个下采样转换器，用于对数据集中的多数类进行下采样。

此组件仅在训练期间运行，而不是在预测期间运行。

参数

sampling_ratio (float) – 被接受为“平衡”的最小少数类与多数类比率。例如，1:4 的比率表示为 0.25，而 1:1 的比率为 1.0。必须在 0 到 1 之间（包括）。默认为 0.25。
sampling_ratio_dict (dict) – 一个字典，指定每个目标值的期望平衡比例。例如，在二元分类中，如果类别 1 是少数类，我们可以指定：sampling_ratio_dict={0: 0.5, 1: 1}，这意味着我们将对类别 0 进行欠采样，使其样本数量是类别 1（少数类:多数类比例 = 0.5）的两倍，并且不对类别 1 进行采样。如果提供，将覆盖 sampling_ratio。默认为 None。
min_samples (int) – 在采样之前或之后，任何类别必须具有的最小样本数。如果必须对某个类别进行下采样，则下采样不会低于此值。要确定严重不平衡，少数类别必须比此值出现的次数少，并且类别比例必须低于 min_percentage。必须大于 0。默认为 100。
min_percentage (float) – 我们容忍的最小类占总数据集的最小百分比，前提是该百分比高于 min_samples。如果未满足 min_percentage 和 min_samples，则将其视为严重不平衡，我们将不会重新采样数据。必须在 0 到 0.5 之间（包括）。默认为 0.1。
random_seed (int) – 用于随机采样的种子。默认为 0。

引发

ValueError – 如果 sampling_ratio 不在 (0, 1] 范围内。
ValueError – 如果 min_sample 不大于 0。
ValueError – 如果 min_percentage 不在 0 到 0.5 之间（包括）。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	True
name	Undersampler
training_only	True

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将采样器拟合到数据。
`fit_resample`	此采样器的重新采样技术。
`fit_transform`	使用采样器组件拟合和转换数据。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	通过对数据进行采样来转换输入数据。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y)#

将采样器拟合到数据。

参数

X (pd.DataFrame) – 输入特征。
y (pd.Series) – 目标。

返回

self

引发

ValueError – 如果 y 为 None。

fit_resample(self, X, y)[source]#

此采样器的重新采样技术。

参数

X (pd.DataFrame) – 要拟合和重新采样的训练数据。
y (pd.Series) – 要拟合和重新采样的训练数据目标。

返回

要保留的训练数据索引。

返回类型

list

fit_transform(self, X, y)#

使用采样器组件拟合和转换数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

转换后的数据。

返回类型

删除了 NaN 行的数据。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)[source]#

通过对数据进行采样来转换输入数据。

参数

X (pd.DataFrame) – 训练特征。
y (pd.Series) – 目标。

返回

转换后的特征和目标。

返回类型

pd.DataFrame, pd.Series

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.URLFeaturizer(random_seed=0, **kwargs)[source]#

可以自动从 URL 提取特征的转换器。

参数: random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{}
modifies_features	True
modifies_target	False
name	URL 特征化器
training_only	False

方法

`clone`	构造具有相同参数和随机状态的新组件。
`default_parameters`	返回此组件的默认参数。
`describe`	描述组件及其参数。
`fit`	将组件拟合到数据。
`fit_transform`	在 X 上拟合并转换 X。
`load`	从文件路径加载组件。
`needs_fitting`	返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。
`parameters`	返回用于初始化组件的参数。
`save`	将组件保存到文件路径。
`transform`	转换数据 X。
`update_parameters`	更新组件的参数字典。

clone(self)#

构造具有相同参数和随机状态的新组件。

返回: 具有相同参数和随机状态的此组件的新实例。

default_parameters(cls)#

返回此组件的默认参数。

我们的约定是 Component.default_parameters == Component().parameters。

返回: 此组件的默认参数。
返回类型: dict

describe(self, print_name=False, return_dict=False)#

描述组件及其参数。

参数

print_name (bool, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

fit(self, X, y=None)#

将组件拟合到数据。

参数

X (pd.DataFrame) – 输入的训练数据，形状为 [样本数, 特征数]
y (pd.Series, optional) – 目标训练数据，长度为 [样本数]

返回

self

引发

MethodPropertyNotFoundError – 如果组件没有 fit 方法或实现了 fit 方法的 component_obj。

fit_transform(self, X, y=None)#

在 X 上拟合并转换 X。

参数

X (pd.DataFrame) – 用于拟合和转换的数据。
y (pd.Series) – 目标数据。

返回

转换后的 X。

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

transform(self, X, y=None)#

转换数据 X。

参数

transform(self, X, y=None)[source]#
transform(self, X, y=None)[source]#

返回

转换后的 X

返回类型

pd.DataFrame

引发

MethodPropertyNotFoundError – 如果转换器没有 transform 方法或实现了 transform 方法的 component_obj。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.VARMAXRegressor(time_index: Optional[Hashable] = None, p: int = 1, q: int = 0, trend: Optional[str] = 'c', random_seed: Union[int, float] = 0, maxiter: int = 10, use_covariates: bool =False, **kwargs)[source]#

带有外生回归器的向量自回归移动平均模型。两个参数 (p, q) 分别是 AR 阶数和 MA 阶数。更多信息请见：https://statsmodels.cn/stable/generated/statsmodels.tsa.statespace.varmax.VARMAX.html。

VARMAXRegressor 目前不支持通过 conda 安装。建议通过 PyPI 安装。

参数

time_index (str) – 指定 X 中提供日期时间对象的列的名称。默认为 None。
p (int) – 最大自回归阶数。默认为 1。
q (int) – 最大移动平均阶数。默认为 0。
trend (str) – 控制确定性趋势。选项包括 [‘n’, ‘c’, ‘t’, ‘ct’]，其中 ‘c’ 表示常数项，‘t’ 表示线性趋势，‘ct’ 表示两者都有。在定义多项式时也可以是可迭代对象，例如 [1, 1, 0, 1]。
random_seed (int) – 随机数生成器的种子。默认为 0。
max_iter (int) – 求解器的最大迭代次数。默认为 10。
use_covariates (bool) – 如果为 True，将在 fit/predict 方法中传递外生变量。如果为 False，预测将仅基于日期时间和目标值。默认为 True。

属性

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 的由 0 组成的数组，因为 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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self) → numpy.ndarray#: 返回长度为 1 的由 0 组成的数组，因为 VARMAX 回归器未定义 feature_importance。

fit(self, X: pandas.DataFrame, y: Optional[pandas.DataFrame] = None)[source]#

将 VARMAX 回归器拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
y (pd.DataFrane) – 形状为 [n_samples, n_series_id_values] 的目标训练数据。

返回

self

引发

ValueError – 如果未传入 y。

get_prediction_intervals(self, X: pandas.DataFrame, y: pandas.DataFrame = None, coverage: List[float] =None, predictions: pandas.Series = None) → Dict[str, pandas.Series][source]#

使用拟合的 VARMAXRegressor 查找预测区间。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.DataFrame) – 形状为 [n_samples, n_series_id_values] 的目标数据。可选。
coverage (list[float]) – 0 到 1 之间的浮点数列表，用于计算预测区间的上限和下限。
predictions (pd.Series) – VARMAX 回归器未使用。

返回

预测区间的字典，字典格式为 {series_id: {coverage}_lower 或 {coverage}_upper}。

返回类型

dict[dict]

static load(file_path)#

从文件路径加载组件。

参数: file_path (str) – 加载文件的位置。
返回: ComponentBase 对象

needs_fitting(self)#

返回布尔值，确定组件在调用 predict、predict_proba、transform 或 feature_importances 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame, y: Optional[pandas.DataFrame] = None) → pandas.Series[source]#

使用拟合的 VARMAX 回归器进行预测。

参数

X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
y (pd.DataFrame) – 形状为 [n_samples, n_series_id_values] 的目标数据。

返回

预测值。

返回类型

pd.Series

引发

ValueError – 如果 X 已传入 fit 但未传入 predict。

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

对标签进行概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
引发: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.XGBoostClassifier(eta=0.1, max_depth=6, min_child_weight=1, n_estimators=100, random_seed=0, eval_metric='logloss', n_jobs=12, **kwargs)[source]#

XGBoost 分类器。

参数

eta (float) – 提升学习率。默认为 0.1。
max_depth (int) – 基础学习器的最大树深度。默认为 6。
min_child_weight (float) – 子节点中所需的实例权重（Hessian）的最小总和。默认为 1.0
n_estimators (int) – 梯度提升树的数量。等同于提升轮数。默认为 100。
random_seed (int) – 随机数生成器的种子。默认为 0。
n_jobs (int) – 用于运行xgboost的并行线程数。请注意，创建线程争用会显著降低算法速度。默认为12。

属性

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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self)#: 已拟合的 XGBoost 分类器的特征重要性。

fit(self, X, y=None)[source]#

将 XGBoost 分类器组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
y (pd.Series) – 目标训练数据，长度为 [n_samples]。

返回

self

get_prediction_intervals(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None, coverage: List[float] = None, predictions: pandas.Series = None) → Dict[str, pandas.Series]#

使用拟合的回归器查找预测区间。

参数

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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X)[source]#

使用已拟合的 XGBoost 分类器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.DataFrame

predict_proba(self, X)[source]#

使用拟合的 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, 可选) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.XGBoostRegressor(eta: float = 0.1, max_depth: int = 6, min_child_weight: int = 1, n_estimators: int = 100, random_seed: Union[int, float] = 0, n_jobs: int = 12, **kwargs)[source]#

XGBoost 回归器。

参数

eta (float) – 提升学习率。默认为 0.1。
max_depth (int) – 基础学习器的最大树深度。默认为 6。
min_child_weight (float) – 子节点中所需的实例权重（Hessian）的最小总和。默认为 1.0
n_estimators (int) – 梯度提升树的数量。等同于提升轮数。默认为 100。
random_seed (int) – 随机数生成器的种子。默认为 0。
n_jobs (int) – 用于运行xgboost的并行线程数。请注意，创建线程争用会显著降低算法速度。默认为12。

属性

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, 可选) – 是否打印组件名称
return_dict (bool, 可选) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

如果 return_dict 为 True 则返回字典，否则返回 None。

返回类型

None 或 dict

property feature_importance(self) → pandas.Series#: 已拟合的 XGBoost 回归器的特征重要性。

fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)[source]#

将 XGBoost 回归器组件拟合到数据。

参数

X (pd.DataFrame) – 输入训练数据，形状为 [n_samples, n_features]。
fit(self, X: pandas.DataFrame, y: Optional[pandas.Series] = None)#

返回

self

使用已拟合的 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 之前是否需要拟合。

对于不需要拟合或其拟合方法不执行任何操作的组件，可以将其重写为 False。

返回: True。

property parameters(self)#: 返回用于初始化组件的参数。

predict(self, X: pandas.DataFrame) → pandas.Series[source]#

使用已拟合的 XGBoost 回归器进行预测。

参数: X (pd.DataFrame) – 数据，形状为 [n_samples, n_features]。
返回: 预测值。
返回类型: pd.Series

predict_proba(self, X: pandas.DataFrame) → pandas.Series#

对标签进行概率估计。

参数: X (pd.DataFrame) – 特征。
返回: 概率估计。
返回类型: pd.Series
引发: MethodPropertyNotFoundError – 如果估计器没有 predict_proba 方法或实现 predict_proba 的 component_obj。

save(self, file_path, pickle_protocol=cloudpickle.DEFAULT_PROTOCOL)#

将组件保存到文件路径。

参数

file_path (str) – 保存文件的位置。
pickle_protocol (int) – pickle 数据流格式。

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

update_dict (dict) – 要更新的参数字典。
reset_fit (bool, 可选) – 如果为 True，将设置 _is_fitted 为 False。