分类器#

分类模型组件。

子模块#

包内容#

类摘要#

`BaselineClassifier`	使用指定策略进行预测的分类器。
`CatBoostClassifier`	CatBoost 分类器，一种使用决策树梯度提升的分类器。CatBoost 是一个开源库，原生支持分类特征。
`DecisionTreeClassifier`	决策树分类器。
`ElasticNetClassifier`	弹性网络分类器。使用带有 elasticnet 惩罚项的逻辑回归作为基础估计器。
`ExtraTreesClassifier`	Extra Trees 分类器。
`KNeighborsClassifier`	K近邻分类器。
`LightGBMClassifier`	LightGBM 分类器。
`LogisticRegressionClassifier`	逻辑回归分类器。
`RandomForestClassifier`	随机森林分类器。
`SVMClassifier`	支持向量机分类器。
`XGBoostClassifier`	XGBoost 分类器。

目录#

class evalml.pipelines.components.estimators.classifiers.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, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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 之前组件是否需要拟合。

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 False。

返回: True。

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

predict(self, X)[source]#

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

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

predict(self, X)[source]#

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

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

predict_proba(self, X)[source]#

将组件保存到文件路径。

参数

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

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

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

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

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

参数

更多信息请查看 https://catboost.ai/
n_estimators (float) – 要构建的最大树数量。默认为 10。
eta (float) – 学习率。默认为 0.03。
max_depth (int) – 基学习器的最大树深度。默认为 6。
bootstrap_type (string) – 定义对象权重采样的方法。可用方法有 ‘Bayesian’, ‘Bernoulli’, ‘MVS’。默认为 None。
silent (boolean) – 是否使用“静默”日志模式。默认为 True。
allow_writing_files (boolean) – 训练时是否允许写入快照文件。默认为 False。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	n_jobs (int or None) – 并行运行的任务数量。-1 表示使用所有进程。默认为 -1。
model_family	{ “n_estimators”: Integer(4, 100), “eta”: Real(0.000001, 1), “max_depth”: Integer(4, 10),}
modifies_features	True
modifies_target	False
name	ModelFamily.CATBOOST
supported_problem_types	CatBoost 分类器
training_only	False

方法

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

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

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

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

clone(self)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

default_parameters(cls)#

描述一个组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

describe(self, print_name=False, return_dict=False)#: [ ProblemTypes.BINARY, ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_BINARY, ProblemTypes.TIME_SERIES_MULTICLASS,]

property feature_importance(self)#

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

参数

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

返回

self

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

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

参数

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 False。

返回: True。

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

property parameters(self)#

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

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

predict(self, X)[source]#

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

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

predict_proba(self, X)[source]#

将组件保存到文件路径。

参数

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

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

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

决策树分类器。

参数

class evalml.pipelines.components.estimators.classifiers.DecisionTreeClassifier(criterion='gini', max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, random_seed=0, **kwargs)[source]#
criterion ({"gini", "entropy"}) – 衡量分割质量的函数。支持的标准有 “gini” 代表基尼不纯度，“entropy” 代表信息增益。默认为 “gini”。
max_features (int, float or {"sqrt", "log2"}) –
- 寻找最佳分割时要考虑的特征数量
- 如果是 int 类型，则每次分割考虑 max_features 个特征。
- 如果是 float 类型，则 max_features 是一个分数，每次分割考虑 int(max_features * n_features) 个特征。
- 如果是 “sqrt”，则 max_features=sqrt(n_features)。
- 如果是 “log2”，则 max_features=log2(n_features)。
如果是 None，则 max_features = n_features。
寻找分割不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
- 分割内部节点所需的最小样本数
- 如果是 int 类型，则将 min_samples_split 视为最小样本数。
如果是 float 类型，则 min_samples_split 是一个分数，ceil(min_samples_split * n_samples) 是每次分割所需的最小样本数。
默认为 2。
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	CatBoost 分类器
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, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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) – 目标训练数据，长度为 [n_samples]。

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

参数

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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。

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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

将组件保存到文件路径。

参数

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

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

更新组件的参数字典。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

弹性网络分类器。使用带有 elasticnet 惩罚项的逻辑回归作为基础估计器。

参数

class evalml.pipelines.components.estimators.classifiers.ElasticNetClassifier(penalty='elasticnet', C=1.0, l1_ratio=0.15, multi_class='auto', solver='saga', n_jobs=-1, random_seed=0, **kwargs)[source]#
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”。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	n_jobs (int) – 用于运行 xgboost 的并行线程数。注意，创建线程争用会显著降低算法速度。默认为 -1。
model_family	{ “C”: Real(0.01, 10), “l1_ratio”: Real(0, 1)}
modifies_features	True
modifies_target	False
name	ModelFamily.LINEAR_MODEL
supported_problem_types	CatBoost 分类器
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, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“name”: name, “parameters”: parameters} 返回描述

返回

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

返回类型

None 或 dict

describe(self, print_name=False, return_dict=False)#: 弹性网络分类器

property feature_importance(self)#

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

参数

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

返回

self

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

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

参数

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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#

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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, optional) – 如果为 True，将设置 _is_fitted 为 False。

update_parameters(self, update_dict, reset_fit=True)#

Extra Trees 分类器。

参数

class evalml.pipelines.components.estimators.classifiers.ExtraTreesClassifier(n_estimators=100, max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, n_jobs=-1, random_seed=0, **kwargs)[source]#
criterion ({"gini", "entropy"}) – 衡量分割质量的函数。支持的标准有 “gini” 代表基尼不纯度，“entropy” 代表信息增益。默认为 “gini”。
max_features (int, float or {"sqrt", "log2"}) –
- 寻找最佳分割时要考虑的特征数量
- 如果是 int 类型，则每次分割考虑 max_features 个特征。
- 如果是 float 类型，则 max_features 是一个分数，每次分割考虑 int(max_features * n_features) 个特征。
- 如果是 “sqrt”，则 max_features=sqrt(n_features)。
- 如果是 “log2”，则 max_features=log2(n_features)。
如果是 None，则 max_features = n_features。
寻找分割不会停止，直到找到至少一个有效的节点样本划分，即使这需要有效检查超过 max_features 个特征。
max_depth (int) – 树的最大深度。默认为 6。
min_samples_split (int or float) –
- 分割内部节点所需的最小样本数
- 如果是 int 类型，则将 min_samples_split 视为最小样本数。
n_estimators (float) – 森林中的树数量。默认为 100。
默认为 2。
allow_writing_files (boolean) – 训练时是否允许写入快照文件。默认为 False。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	2. (默认为) –
model_family	{ “n_estimators”: Integer(10, 1000), “max_features”: [“sqrt”, “log2”], “max_depth”: Integer(4, 10),}
modifies_features	True
modifies_target	False
name	ModelFamily.EXTRA_TREES
supported_problem_types	CatBoost 分类器
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`	更新组件的参数字典。

Extra Trees 分类器

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

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

clone(self)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

default_parameters(cls)#

描述一个组件及其参数。

参数

print_name (bool, optional) – 是否打印组件名称
return_dict (bool, optional) – 是否以字典格式 {“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 之前组件是否需要拟合。

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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#

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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, optional) – 如果为 True，将设置 _is_fitted 为 False。

update_parameters(self, update_dict, reset_fit=True)#

K近邻分类器。

参数

class evalml.pipelines.components.estimators.classifiers.KNeighborsClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, random_seed=0, **kwargs)[source]#
n_neighbors (int) – 默认使用的邻居数量。默认为 5。
weights ({‘uniform’, ‘distance’} or callable) –
- 预测中使用的权重函数。可以是
- ‘uniform’ : 均匀权重。每个邻域中的所有点都被平等加权。
- ‘distance’ : 按距离的倒数加权点。在这种情况下，查询点较近的邻居比距离较远的邻居影响更大。
[callable] : 用户定义的函数，接受距离数组，并返回包含权重的相同形状的数组。
默认为 “uniform”。
algorithm ({‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}) –
- 计算最近邻的算法
- ‘ball_tree’ 将使用 BallTree
- ‘kd_tree’ 将使用 KDTree
‘brute’ 将使用暴力搜索。
‘auto’ 将尝试根据传递给 fit 方法的值决定最合适的算法。默认为 “auto”。注意：在稀疏输入上拟合将覆盖此参数的设置，使用暴力搜索。
leaf_size (int) – 传递给 BallTree 或 KDTree 的叶大小。这会影响构造和查询的速度，以及存储树所需的内存。最佳值取决于问题的性质。默认为 30。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	p (int) – Minkowski 度量的幂参数。当 p = 1 时，等同于使用 manhattan_distance (l1)，当 p = 2 时，等同于使用 euclidean_distance (l2)。对于任意 p，使用 minkowski_distance (l_p)。默认为 2。
model_family	{ “n_neighbors”: Integer(2, 12), “weights”: [“uniform”, “distance”], “algorithm”: [“auto”, “ball_tree”, “kd_tree”, “brute”], “leaf_size”: Integer(10, 30), “p”: Integer(1, 5),}
modifies_features	True
modifies_target	False
name	ModelFamily.K_NEIGHBORS
supported_problem_types	CatBoost 分类器
training_only	False

方法

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

返回与输入特征数量匹配的全为 0 的数组，因为 KNN 分类器没有定义 feature_importance。

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

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

clone(self)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

default_parameters(cls)#

描述一个组件及其参数。

参数

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

返回

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

返回类型

None 或 dict

describe(self, print_name=False, return_dict=False)#: property feature_importance(self)#

返回与输入特征数量匹配的全为 0 的数组，因为 KNN 分类器没有定义 feature_importance。

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

参数

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 False。

返回: True。

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

property parameters(self)#

将估计器拟合到数据。

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

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

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

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

LightGBM 分类器。

参数

boosting_type (string) – 使用的提升类型。默认为“gbdt”。 - 'gbdt' 使用传统的梯度提升决策树 - "dart" 使用 Dropout 遇上多个加性回归树 (Dropouts meet Multiple Additive Regression Trees) - "goss" 使用基于梯度的单侧采样 (Gradient-based One-Side Sampling) - "rf" 使用随机森林
learning_rate (float) – 提升学习率。默认为 0.1。
n_estimators (int) – 要拟合的提升树数量。默认为 100。
max_depth (int) – 基本学习器的最大树深度，<=0 表示无限制。默认为 0。
num_leaves (int) – 基本学习器的最大树叶节点数。默认为 31。
min_child_samples (int) – 叶节点（子节点）所需的最小数据量。默认为 20。
bagging_fraction (float) – 如果小于 1.0，LightGBM 将在每次迭代（树）时随机选择特征子集，且不进行重采样。例如，如果设置为 0.8，LightGBM 将在训练每棵树之前选择 80% 的特征。这可用于加速训练和处理过拟合。默认为 0.9。
bagging_freq (int) – 数据采样（bagging）的频率。0 表示禁用数据采样。k 表示每 k 次迭代执行一次数据采样。每第 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	CatBoost 分类器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

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

描述一个组件及其参数。

参数

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

返回

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

返回类型

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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, optional) – 如果为 True，将设置 _is_fitted 为 False。

class evalml.pipelines.components.estimators.classifiers.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”。
penalty ({"l1", "l2", "elasticnet", "none"}) – 惩罚中使用的范数。默认为 “elasticnet”。
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” 惩罚
默认为“lbfgs”。
默认为 “saga”。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “penalty”: [“l2”], “C”: Real(0.01, 10),}
model_family	{ “C”: Real(0.01, 10), “l1_ratio”: Real(0, 1)}
modifies_features	True
modifies_target	False
name	逻辑回归分类器
supported_problem_types	CatBoost 分类器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

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

描述一个组件及其参数。

参数

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

返回

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

返回类型

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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#

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.estimators.classifiers.RandomForestClassifier(n_estimators=100, max_depth=6, n_jobs=-1, random_seed=0, **kwargs)[source]#

随机森林分类器。

参数

class evalml.pipelines.components.estimators.classifiers.ExtraTreesClassifier(n_estimators=100, max_features='sqrt', max_depth=6, min_samples_split=2, min_weight_fraction_leaf=0.0, n_jobs=-1, random_seed=0, **kwargs)[source]#
max_depth (int) – 基本学习器的最大树深度。默认为 6。
allow_writing_files (boolean) – 训练时是否允许写入快照文件。默认为 False。
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	CatBoost 分类器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

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

描述一个组件及其参数。

参数

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

返回

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

返回类型

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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#

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.estimators.classifiers.SVMClassifier(C=1.0, kernel='rbf', gamma='auto', probability=True, random_seed=0, **kwargs)[source]#

支持向量机分类器。

参数

C (float) – 正则化参数。正则化强度与 C 成反比。必须为严格正数。惩罚项为平方 l2 惩罚项。默认为 1.0。
kernel ({"poly", "rbf", "sigmoid"}) – 指定算法中使用的核函数类型。默认为“rbf”。
gamma ({"scale", "auto"} or float) – “rbf”、“poly”和“sigmoid”核函数的系数。默认为“auto”。 - 如果 gamma='scale'，则使用 1 / (n_features * X.var()) 作为 gamma 值 - 如果为“auto”（默认），则使用 1 / n_features
probability (boolean) – 是否启用概率估计。默认为 True。
random_seed (int) – 随机数生成器的种子。默认为 0。

属性

hyperparameter_ranges	{ “C”: Real(0, 10), “kernel”: [“poly”, “rbf”, “sigmoid”], “gamma”: [“scale”, “auto”],}
model_family	ModelFamily.SVM
modifies_features	True
modifies_target	False
name	支持向量机分类器
supported_problem_types	CatBoost 分类器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

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

描述一个组件及其参数。

参数

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

返回

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

返回类型

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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#

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

参数: predict_proba(self, X: pandas.DataFrame) → pandas.Series#
返回: X (pd.DataFrame) – 特征。
返回类型: pd.Series
引发: 概率估计。

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

将组件保存到文件路径。

参数

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

update_parameters(self, update_dict, reset_fit=True)#

更新组件的参数字典。

参数

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

class evalml.pipelines.components.estimators.classifiers.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	无
SEED_MIN	无
supported_problem_types	CatBoost 分类器
training_only	False

方法

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

clone(self)#

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

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

default_parameters(cls)#

返回此组件的默认参数。

我们的惯例是 Component.default_parameters == Component().parameters。

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

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

描述一个组件及其参数。

参数

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

返回

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

返回类型

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

对于不需要拟合或其 fit 方法不做任何事情的组件，可以将其覆盖为 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, optional) – 如果为 True，将设置 _is_fitted 为 False。