目标#

EvalML 标准和自定义目标。

子模块#

包内容#

类摘要#

`AccuracyBinary`	二元分类的准确率得分。
`AccuracyMulticlass`	多元分类的准确率得分。
`AUC`	二元分类的 AUC 得分。
`AUCMacro`	使用宏平均的多元分类 AUC 得分。
`AUCMicro`	使用微平均的多元分类 AUC 得分。
`AUCWeighted`	使用加权平均的多元分类 AUC 得分。
`BalancedAccuracyBinary`	二元分类的平衡准确率得分。
`BalancedAccuracyMulticlass`	多元分类的平衡准确率得分。
`BinaryClassificationObjective`	所有二元分类目标的基类。
`CostBenefitMatrix`	使用成本效益矩阵进行评分。得分量化给定值的收益，因此较高的数值得分表示更好的得分。成本和得分可以是负数，表示该值没有收益。例如，在货币利润的情况下，负成本和/或得分表示现金流失。
`ExpVariance`	回归的解释方差得分。
`F1`	二元分类的 F1 得分。
`F1Macro`	使用宏平均的多元分类 F1 得分。
`F1Micro`	使用微平均的多元分类 F1 得分。
`F1Weighted`	使用加权平均的多元分类 F1 得分。
`FraudCost`	评估由于欺诈造成的总交易金额的损失百分比。
`Gini`	二元分类的基尼系数。
`LeadScoring`	潜在客户评分。
`LogLossBinary`	二元分类的对数损失。
`LogLossMulticlass`	多元分类的对数损失。
`MAE`	回归的平均绝对误差。
`MAPE`	时间序列回归的平均绝对百分比误差。缩放 100 倍以返回百分比。
`MASE`	时间序列回归的平均绝对比例误差。
`MaxError`	回归的最大残差误差。
`MCCBinary`	二元分类的马修斯相关系数。
`MCCMulticlass`	多元分类的马修斯相关系数。
`MeanSquaredLogError`	回归的均方对数误差。
`MedianAE`	回归的中位数绝对误差。
`MSE`	回归的均方误差。
`MulticlassClassificationObjective`	所有多元分类目标的基类。
`ObjectiveBase`	所有目标的基类。
`Precision`	二元分类的精确率得分。
`PrecisionMacro`	使用宏平均的多元分类精确率得分。
`PrecisionMicro`	使用微平均的多元分类精确率得分。
`PrecisionWeighted`	使用加权平均的多元分类精确率得分。
`R2`	回归的决定系数。
`Recall`	二元分类的召回率得分。
`RecallMacro`	使用宏平均的多元分类召回率得分。
`RecallMicro`	使用微平均的多元分类召回率得分。
`RecallWeighted`	使用加权平均的多元分类召回率得分。
`RegressionObjective`	所有回归目标的基类。
`RootMeanSquaredError`	回归的均方根误差。
`RootMeanSquaredLogError`	回归的均方根对数误差。
`SensitivityLowAlert`	低警报率下的敏感性。
`SMAPE`	时间序列回归的对称平均绝对百分比误差。缩放 100 倍以返回百分比。

函数#

`get_all_objective_names`	获取所有目标的名称列表。
`get_core_objective_names`	获取所有有效的核心目标列表。
`get_core_objectives`	返回与给定问题类型关联的所有核心目标实例。
`get_default_recommendation_objectives`	获取给定问题类型的默认推荐评分指标。
`get_non_core_objectives`	获取非核心目标类。
`get_objective`	返回与给定目标名称对应的 Objective 类。
`get_optimization_objectives`	获取用于优化的目标。
`get_ranking_objectives`	获取用于管道排名的目标。
`normalize_objectives`	给定每个目标的最小值和最大值，将目标从 [0, inf) 范围转换为 [0, 1] 范围。
`organize_objectives`	生成要考虑的目标，可选择修改默认设置。
`ranking_only_objectives`	获取仅用于排名的目标类。
`recommendation_score`	根据一组目标的得分，计算模型的推荐得分。

内容#

class evalml.objectives.AccuracyBinary[source]#

二元分类的准确率得分。

示例

>>> y_true = pd.Series([0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(AccuracyBinary().objective_function(y_true, y_pred), 0.6363636)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	二元准确率
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类准确率得分的目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类准确率得分的目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.AccuracyMulticlass[source]#

多元分类的准确率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(AccuracyMulticlass().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	多元准确率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	多元分类准确率得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 多元分类准确率得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.AUC[source]#

二元分类的 AUC 得分。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(AUC().objective_function(y_true, y_pred), 0.5714285)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	AUC
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类 AUC 得分的目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类 AUC 得分的目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.AUCMacro[source]#

使用宏平均的多元分类 AUC 得分。

示例

>>> y_true = [0, 1, 2, 0, 2, 1]
>>> y_pred = [[0.7, 0.2, 0.1],
...           [0.1, 0.0, 0.9],
...           [0.1, 0.3, 0.6],
...           [0.9, 0.1, 0.0],
...           [0.6, 0.1, 0.3],
...           [0.5, 0.5, 0.0]]
>>> np.testing.assert_almost_equal(AUCMacro().objective_function(y_true, y_pred), 0.75)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	AUC 宏平均
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用宏平均的多元分类 AUC 得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用宏平均的多元分类 AUC 得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.AUCMicro[source]#

使用微平均的多元分类 AUC 得分。

示例

>>> y_true = [0, 1, 2, 0, 2, 1]
>>> y_pred = [[0.7, 0.2, 0.1],
...           [0.3, 0.5, 0.2],
...           [0.1, 0.3, 0.6],
...           [0.9, 0.1, 0.0],
...           [0.3, 0.1, 0.6],
...           [0.5, 0.5, 0.0]]
>>> np.testing.assert_almost_equal(AUCMicro().objective_function(y_true, y_pred), 0.9861111)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	AUC 微平均
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用微平均的多元分类 AUC 得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用微平均的多元分类 AUC 得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.AUCWeighted[source]#

使用加权平均的多元分类 AUC 得分。

示例

>>> y_true = [0, 1, 2, 0, 2, 1]
>>> y_pred = [[0.7, 0.2, 0.1],
...           [0.1, 0.0, 0.9],
...           [0.1, 0.3, 0.6],
...           [0.1, 0.2, 0.7],
...           [0.6, 0.1, 0.3],
...           [0.5, 0.2, 0.3]]
>>> np.testing.assert_almost_equal(AUCWeighted().objective_function(y_true, y_pred), 0.4375)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	AUC 加权平均
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用加权平均的多元分类 AUC 得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用加权平均的多元分类 AUC 得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.BalancedAccuracyBinary[source]#

二元分类的平衡准确率得分。

示例

>>> y_true = pd.Series([0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(BalancedAccuracyBinary().objective_function(y_true, y_pred), 0.60)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	二元平衡准确率
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类平衡准确率得分的目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类平衡准确率得分的目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.BalancedAccuracyMulticlass[source]#

多元分类的平衡准确率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(BalancedAccuracyMulticlass().objective_function(y_true, y_pred), 0.5555555)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	多元平衡准确率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	多元分类平衡准确率得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 多元分类平衡准确率得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.BinaryClassificationObjective[source]#

所有二元分类目标的基类。

属性

problem_types

[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`expected_range`	返回目标的预期范围，这不一定是可能的范围。
`greater_is_better`	返回一个布尔值，指示更高的分数是否表示更好的模型性能。
`is_bounded_like_percentage`	返回此目标是否在 0 到 1（含）之间有界。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`name`	返回描述目标的名称。
`objective_function`	根据指定的指标，计算提供的预测值与实际标签的相对值。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`perfect_score`	返回通过在完美模型上评估此目标获得的分数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`score_needs_proba`	返回一个布尔值，指示 score() 方法是否需要概率估计。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)[source]#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

property expected_range(cls)#

返回目标的预期范围，这不一定是可能的范围。

例如，我们预期的 R2 范围是 [-1, 1]，尽管实际范围是 (-inf, 1]。

property greater_is_better(cls)#: 返回一个布尔值，指示更高的分数是否表示更好的模型性能。

property is_bounded_like_percentage(cls)#: 返回此目标是否在 0 到 1（含）之间有界。

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

property name(cls)#: 返回描述目标的名称。

abstract classmethod objective_function(cls, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

根据指定的指标，计算提供的预测值与实际标签的相对值。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

用于计算分数的数值

optimize_threshold(self, ypred_proba, y_true, X=None)[source]#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

property perfect_score(cls)#: 返回通过在完美模型上评估此目标获得的分数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

property score_needs_proba(cls)#

返回一个布尔值，指示 score() 方法是否需要概率估计。

对于使用预测概率的目标（例如对数损失或 AUC），此应为 true；对于将预测类别标签与实际标签进行比较的目标（例如 F1 或相关性），此应为 false。

validate_inputs(self, y_true, y_predicted)[source]#: 验证评分的输入。

class evalml.objectives.CostBenefitMatrix(true_positive, true_negative, false_positive, false_negative)[source]#

使用成本效益矩阵进行评分。得分量化给定值的收益，因此较高的数值得分表示更好的得分。成本和得分可以是负数，表示该值没有收益。例如，在货币利润的情况下，负成本和/或得分表示现金流失。

参数

true_positive (float) – 与真阳性预测相关的成本。
true_negative (float) – 与真阴性预测相关的成本。
false_positive (float) – 与假阳性预测相关的成本。
false_negative (float) – 与假阴性预测相关的成本。

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	成本效益矩阵
perfect_score	None
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用预测值和真实值计算成本效益。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#

使用预测值和真实值计算成本效益。

参数

y_predicted (pd.Series) – 预测的标签。
y_true (pd.Series) – 真实标签。
y_train (pd.Series) – 忽略。
X (pd.DataFrame) – 忽略。
sample_weight (pd.DataFrame) – 忽略。

返回

成本效益矩阵得分

返回类型

float

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.ExpVariance[source]#

回归的解释方差得分。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(ExpVariance().objective_function(y_true, y_pred), 0.7760736)

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	ExpVariance
perfect_score	1.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归解释方差得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归解释方差得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.F1[source]#

二元分类的 F1 得分。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(F1().objective_function(y_true, y_pred), 0.25)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	F1
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类 F1 得分的目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类 F1 得分的目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.F1Macro[source]#

使用宏平均的多元分类 F1 得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(F1Macro().objective_function(y_true, y_pred), 0.5476190)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	F1 宏平均
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用宏平均的多元分类 F1 得分的目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用宏平均的多元分类 F1 得分的目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.F1Micro[source]#

使用微平均的多元分类 F1 得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(F1Micro().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	F1 Micro
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	多类别分类F1分数的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 多类别分类F1分数的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.F1Weighted[source]#

使用加权平均的多元分类 F1 得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(F1Weighted().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	F1 加权
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用加权平均的多类别分类F1分数的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用加权平均的多类别分类F1分数的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.FraudCost(retry_percentage=0.5, interchange_fee=0.02, fraud_payout_percentage=1.0, amount_col='amount')[source]#

评估由于欺诈造成的总交易金额的损失百分比。

参数

retry_percentage (float) – 如果交易被拒绝，将重试的客户百分比。介于0和1之间。默认为0.5。
interchange_fee (float) – 每笔成功交易您支付的费用百分比。介于0和1之间。默认为0.02。
fraud_payout_percentage (float) – 无法追回的欺诈款项百分比。介于0和1之间。默认为1.0。
amount_col (str) – 数据中包含金额的列名。默认为“amount”。

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	True
name	欺诈成本
perfect_score	0.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	根据预测值、真实值以及包含交易金额的数据框计算每笔交易因欺诈造成的损失金额。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, X, y_train=None, sample_weight=None)[source]#

根据预测值、真实值以及包含交易金额的数据框计算每笔交易因欺诈造成的损失金额。

参数

y_predicted (pd.Series) – 预测的欺诈标签。
y_true (pd.Series) – 真实的欺诈标签。
y_train (pd.Series) – 忽略。
X (pd.DataFrame) – 包含交易金额的数据。
sample_weight (pd.DataFrame) – 忽略。

返回

每笔交易因欺诈造成的损失金额。

返回类型

float

引发

ValueError – 如果 amount_col 在输入数据中不是一个有效列。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

evalml.objectives.get_all_objective_names()[source]#

获取所有目标的名称列表。

返回: 评估函数名称
返回类型: list (str)

evalml.objectives.get_core_objective_names()[source]#

获取所有有效的核心目标列表。

返回: 评估函数名称。
返回类型: list[str]

evalml.objectives.get_core_objectives(problem_type)[source]#

返回与给定问题类型关联的所有核心目标实例。

核心评估函数旨在适用于任何数据集，无需额外配置。

参数: problem_type (str/ProblemTypes) – 问题类型
返回: ObjectiveBase 类列表

示例

>>> for objective in get_core_objectives("regression"):
...     print(objective.name)
ExpVariance
MaxError
MedianAE
MSE
MAE
R2
Root Mean Squared Error
>>> for objective in get_core_objectives("binary"):
...     print(objective.name)
MCC Binary
Log Loss Binary
Gini
AUC
Precision
F1
Balanced Accuracy Binary
Accuracy Binary

evalml.objectives.get_default_recommendation_objectives(problem_type, imbalanced=False)[source]#

获取给定问题类型的默认推荐评分指标。

参数

problem_type (str/ProblemType) – 问题类型
imbalanced (boolean) – 对于多类别问题，指示类别是否不平衡。默认为 False

返回

与 ObjectiveBase 评估函数对应的字符串评估函数名称集合

evalml.objectives.get_non_core_objectives()[source]#

获取非核心目标类。

非核心评估函数是领域特定的评估函数。用户通常需要在 AutoMLSearch 中使用它们之前进行配置。

返回: ObjectiveBase 类列表

evalml.objectives.get_objective(objective, return_instance=False, **kwargs)[source]#

返回与给定目标名称对应的 Objective 类。

参数

objective (str 或 ObjectiveBase) – 评估函数类的名称或实例。
return_instance (bool) – 是否返回评估函数实例。仅当 objective 为 str 类型时适用。请注意，实例将使用默认参数初始化。
kwargs (Any) – 传递给评估函数的任意关键字参数。仅当 return_instance=True 时使用。

返回

如果参数 objective 是 ObjectiveBase 类型，则返回 ObjectiveBase。如果 objective 是有效的评估函数名称，函数将返回与该名称对应的类。如果 return_instance 为 True，则将返回该评估函数的实例。

引发

TypeError – 如果 objective 为 None。
TypeError – 如果 objective 不是字符串也不是 ObjectiveBase 的实例。
ObjectiveNotFoundError – 如果输入的 objective 不是有效的评估函数。
ObjectiveCreationError – 如果无法正确创建 objective。

evalml.objectives.get_optimization_objectives(problem_type)[source]#

获取用于优化的目标。

参数: problem_type (str/ProblemTypes) – 问题类型
返回: ObjectiveBase 类列表

evalml.objectives.get_ranking_objectives(problem_type)[source]#

获取用于管道排名的目标。

参数: problem_type (str/ProblemTypes) – 问题类型
返回: ObjectiveBase 类列表

class evalml.objectives.Gini[source]#

二元分类的基尼系数。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(Gini().objective_function(y_true, y_pred), 0.1428571)

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	Gini
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二分类Gini系数的评估函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二分类Gini系数的评估函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.LeadScoring(true_positives=1, false_positives=-1)[source]#

潜在客户评分。

参数

true_positives (int) – 真阳性的奖励。默认为 1。
false_positives (int) – 假阳性的成本。应为负数。默认为 -1。

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	线索评分
perfect_score	None
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	计算每条线索的利润。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#

计算每条线索的利润。

参数

y_predicted (pd.Series) – 预测的标签。
y_true (pd.Series) – 真实标签。
y_train (pd.Series) – 忽略。
X (pd.DataFrame) – 忽略。
sample_weight (pd.DataFrame) – 忽略。

返回

每条线索的利润

返回类型

float

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.LogLossBinary[source]#

二元分类的对数损失。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(LogLossBinary().objective_function(y_true, y_pred), 19.6601745)

属性

expected_range	[0, 1]
greater_is_better	False
is_bounded_like_percentage	False
name	二分类对数损失
perfect_score	0.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二分类对数损失的评估函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二分类对数损失的评估函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.LogLossMulticlass[source]#

多元分类的对数损失。

示例

>>> y_true = [0, 1, 2, 0, 2, 1]
>>> y_pred = [[0.7, 0.2, 0.1],
...           [0.3, 0.5, 0.2],
...           [0.1, 0.3, 0.6],
...           [0.9, 0.1, 0.0],
...           [0.3, 0.1, 0.6],
...           [0.5, 0.5, 0.0]]
>>> np.testing.assert_almost_equal(LogLossMulticlass().objective_function(y_true, y_pred), 0.4783301)

属性

expected_range	[0, 1]
greater_is_better	False
is_bounded_like_percentage	False
name	多类别对数损失
perfect_score	0.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	True

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	多类别分类对数损失的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 多类别分类对数损失的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MAE[source]#

回归的平均绝对误差。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MAE().objective_function(y_true, y_pred), 0.2727272)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	MAE
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归平均绝对误差的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归平均绝对误差的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MAPE[source]#

时间序列回归的平均绝对百分比误差。缩放 100 倍以返回百分比。

仅对非零输入有效。否则将抛出 ValueError。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MAPE().objective_function(y_true, y_pred), 15.9848484)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	平均绝对百分比误差
perfect_score	0.0
problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	时间序列回归平均绝对百分比误差的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 时间序列回归平均绝对百分比误差的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MASE[source]#

时间序列回归的平均绝对比例误差。

仅当 y_train 中存在非零输入时有效。否则将抛出 ValueError。

示例

>>> y_train = pd.Series([5, 0.5, 4, 6, 3, 5, 2])
>>> y_true = pd.Series([3, -0.5, 2, 7, 2])
>>> y_pred = pd.Series([2.5, 0.0, 2, 8, 1.25])
>>> np.testing.assert_almost_equal(MASE().objective_function(y_true, y_pred, y_train), 0.18333333333333335)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	平均绝对比例误差
perfect_score	0.0
problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	时间序列回归平均绝对比例误差的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train, X=None, sample_weight=None)[source]#: 时间序列回归平均绝对比例误差的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MaxError[source]#

回归的最大残差误差。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MaxError().objective_function(y_true, y_pred), 1.0)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	MaxError
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归最大残差的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归最大残差的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MCCBinary[source]#

二元分类的马修斯相关系数。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(MCCBinary().objective_function(y_true, y_pred), 0.2390457)

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	二分类 MCC (Matthews 相关系数)
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二分类 Matthews 相关系数的评估函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二分类 Matthews 相关系数的评估函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.MCCMulticlass[source]#

多元分类的马修斯相关系数。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(MCCMulticlass().objective_function(y_true, y_pred), 0.325)

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	多类别 MCC (Matthews 相关系数)
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	多类别分类 Matthews 相关系数的评估函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 多类别分类 Matthews 相关系数的评估函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MeanSquaredLogError[source]#

回归的均方对数误差。

仅对非负输入有效。否则将抛出 ValueError。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MeanSquaredLogError().objective_function(y_true, y_pred), 0.0171353)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	均方对数误差
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归均方对数误差的评估函数。
`positive_only`	如果为 True，则此评估函数仅对正数数据有效。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归均方对数误差的评估函数。

positive_only(self)#: 如果为 True，则此评估函数仅对正数数据有效。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MedianAE[source]#

回归的中位数绝对误差。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MedianAE().objective_function(y_true, y_pred), 0.25)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	MedianAE
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归的中位数绝对误差目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归的中位数绝对误差目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MSE[source]#

回归的均方误差。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(MSE().objective_function(y_true, y_pred), 0.1590909)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	MSE
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归的均方误差目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归的均方误差目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.MulticlassClassificationObjective[source]#

所有多元分类目标的基类。

属性

problem_types

[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`expected_range`	返回目标的预期范围，这不一定是可能的范围。
`greater_is_better`	返回一个布尔值，指示更高的分数是否表示更好的模型性能。
`is_bounded_like_percentage`	返回此目标是否在 0 到 1（含）之间有界。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`name`	返回描述目标的名称。
`objective_function`	根据指定的指标，计算提供的预测值与实际标签的相对值。
`perfect_score`	返回通过在完美模型上评估此目标获得的分数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`score_needs_proba`	返回一个布尔值，指示 score() 方法是否需要概率估计。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property expected_range(cls)#

返回目标的预期范围，这不一定是可能的范围。

例如，我们预期的 R2 范围是 [-1, 1]，尽管实际范围是 (-inf, 1]。

property greater_is_better(cls)#: 返回一个布尔值，指示更高的分数是否表示更好的模型性能。

property is_bounded_like_percentage(cls)#: 返回此目标是否在 0 到 1（含）之间有界。

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

property name(cls)#: 返回描述目标的名称。

abstract classmethod objective_function(cls, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

根据指定的指标，计算提供的预测值与实际标签的相对值。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

用于计算分数的数值

property perfect_score(cls)#: 返回通过在完美模型上评估此目标获得的分数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

property score_needs_proba(cls)#

返回一个布尔值，指示 score() 方法是否需要概率估计。

对于使用预测概率的目标（例如对数损失或 AUC），此应为 true；对于将预测类别标签与实际标签进行比较的目标（例如 F1 或相关性），此应为 false。

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

evalml.objectives.normalize_objectives(objectives_to_normalize, max_objectives, min_objectives)[source]#

给定每个目标的最小值和最大值，将目标从 [0, inf) 范围转换为 [0, 1] 范围。

参数

objectives_to_normalize (dict[str,float]) – 将目标映射到值的字典
max_objectives (dict[str,float]) – 用于归一化的目标与最大值的映射
min_objectives (dict[str,float]) – 用于归一化的目标与最小值的映射

返回

一个将目标名称映射到其新的归一化值的字典

class evalml.objectives.ObjectiveBase[source]#

所有目标的基类。

属性

problem_types

None

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`expected_range`	返回目标的预期范围，这不一定是可能的范围。
`greater_is_better`	返回一个布尔值，指示更高的分数是否表示更好的模型性能。
`is_bounded_like_percentage`	返回此目标是否在 0 到 1（含）之间有界。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`name`	返回描述目标的名称。
`objective_function`	根据指定的指标，计算提供的预测值与实际标签的相对值。
`perfect_score`	返回通过在完美模型上评估此目标获得的分数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`score_needs_proba`	返回一个布尔值，指示 score() 方法是否需要概率估计。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)[source]#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property expected_range(cls)#

返回目标的预期范围，这不一定是可能的范围。

例如，我们预期的 R2 范围是 [-1, 1]，尽管实际范围是 (-inf, 1]。

property greater_is_better(cls)#: 返回一个布尔值，指示更高的分数是否表示更好的模型性能。

property is_bounded_like_percentage(cls)#: 返回此目标是否在 0 到 1（含）之间有界。

classmethod is_defined_for_problem_type(cls, problem_type)[source]#: 返回目标是否为某个问题类型定义。

property name(cls)#: 返回描述目标的名称。

abstract classmethod objective_function(cls, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#

根据指定的指标，计算提供的预测值与实际标签的相对值。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

用于计算分数的数值

property perfect_score(cls)#: 返回通过在完美模型上评估此目标获得的分数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

property score_needs_proba(cls)#

返回一个布尔值，指示 score() 方法是否需要概率估计。

对于使用预测概率的目标（例如对数损失或 AUC），此应为 true；对于将预测类别标签与实际标签进行比较的目标（例如 F1 或相关性），此应为 false。

validate_inputs(self, y_true, y_predicted)[source]#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

evalml.objectives.organize_objectives(problem_type, include=None, exclude=None, imbalanced=False)[source]#

生成要考虑的目标，可选择修改默认设置。

参数

problem_type (str/ProblemType) – 问题类型
include (list[str/ObjectiveBase]) – 要包含在默认目标之外的目标列表。默认为 None。
exclude (list[str/ObjectiveBase]) – 要从默认目标中排除的目标列表。默认为 None。
imbalanced (boolean) – 对于多类别问题，指示类别是否不平衡。默认为 False

返回

与 ObjectiveBase 目标相对应的字符串目标名称列表

引发

ValueError – 如果任何要包含或排除的目标对于问题类型无效
ValueError – 如果要排除的目标不在默认目标中

class evalml.objectives.Precision[source]#

二元分类的精确率得分。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(Precision().objective_function(y_true, y_pred), 1.0)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Precision
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类的精确率分数目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类的精确率分数目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.PrecisionMacro[source]#

使用宏平均的多元分类精确率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(PrecisionMacro().objective_function(y_true, y_pred), 0.5555555)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Macro 精确率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用 macro 平均的多类别分类的精确率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用 macro 平均的多类别分类的精确率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.PrecisionMicro[source]#

使用微平均的多元分类精确率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(PrecisionMicro().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Micro 精确率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用 micro 平均的多类别分类的精确率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用 micro 平均的多类别分类的精确率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.PrecisionWeighted[source]#

使用加权平均的多元分类精确率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(PrecisionWeighted().objective_function(y_true, y_pred), 0.5606060)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Weighted 精确率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用加权平均的多类别分类的精确率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用加权平均的多类别分类的精确率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.R2[source]#

回归的决定系数。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(R2().objective_function(y_true, y_pred), 0.7638036)

属性

expected_range	None
greater_is_better	True
is_bounded_like_percentage	False
name	R2
perfect_score	1
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归的决定系数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归的决定系数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

evalml.objectives.ranking_only_objectives()[source]#

获取仅用于排名的目标类。

仅用于排名的目标是指对于评估模型性能有用，但不应因各种原因在 AutoMLSearch 期间用作优化目标的目标。

返回: ObjectiveBase 类列表

class evalml.objectives.Recall[source]#

二元分类的召回率得分。

示例

>>> y_true = pd.Series([0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1])
>>> y_pred = pd.Series([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
>>> np.testing.assert_almost_equal(Recall().objective_function(y_true, y_pred), 0.1428571)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Recall
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	将学习到的阈值应用于预测概率以获得预测类别。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	二元分类的召回率分数目标函数。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, threshold=0.5, X=None)#

将学习到的阈值应用于预测概率以获得预测类别。

参数

ypred_proba (pd.Series, np.ndarray) – 分类器的预测概率
threshold (float, optional) – 用于进行预测的阈值。默认为 0.5。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

预测结果

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 二元分类的召回率分数目标函数。

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.RecallMacro[source]#

使用宏平均的多元分类召回率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(RecallMacro().objective_function(y_true, y_pred), 0.5555555)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Macro 召回率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用 macro 平均的多类别分类的召回率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用 macro 平均的多类别分类的召回率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.RecallMicro[source]#

使用微平均的多元分类召回率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(RecallMicro().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Micro 召回率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用 micro 平均的多类别分类的召回率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用 micro 平均的多类别分类的召回率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.RecallWeighted[source]#

使用加权平均的多元分类召回率得分。

示例

>>> y_true = pd.Series([0, 1, 0, 2, 0, 1, 2, 1, 2, 0, 2])
>>> y_pred = pd.Series([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2])
>>> np.testing.assert_almost_equal(RecallWeighted().objective_function(y_true, y_pred), 0.5454545)

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	Weighted 召回率
perfect_score	1.0
problem_types	[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	使用加权平均的多类别分类的召回率分数目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 使用加权平均的多类别分类的召回率分数目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

evalml.objectives.recommendation_score(objectives, prioritized_objective=None, custom_weights=None)[source]#

根据一组目标的得分，计算模型的推荐得分。

此推荐分数是给定目标的加权平均值，默认情况下权重均等。传入一个优先目标将赋予该目标优先权重，而所有其他目标将平均分配剩余权重。

参数

objectives (dict[str,float]) – 一个将目标映射到其值的字典。目标应是一个介于 0 和 1 之间的浮点数，值越大越好。如果目标分数不是以这种方式表示的，则应先使用 normalize_objectives 函数进行归一化。
prioritized_objective (str) – 一个可选的优先目标名称，应赋予比其他对分数有贡献的目标更高的权重（总权重的 50%）。默认为 None，此时所有目标权重均等。
custom_weights (dict[str,float]) – 一个将目标名称映射到相应权重的字典，权重介于 0 和 1 之间。如果列出了所有目标，权重总和应为 1。如果列出的是目标子集，权重总和应小于 1，剩余权重将平均分配给剩余目标。不应与 prioritized_objective 同时使用。

返回

一个介于 0 和 100 之间的值，表示给定一组评估目标后我们对某个 pipeline 的推荐程度。

引发

ValueError – 如果要优先考虑的目标不在已知目标中，或者自定义权重不是介于 0 和 1 之间的浮点数。

class evalml.objectives.RegressionObjective[source]#

所有回归目标的基类。

属性

problem_types

[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`expected_range`	返回目标的预期范围，这不一定是可能的范围。
`greater_is_better`	返回一个布尔值，指示更高的分数是否表示更好的模型性能。
`is_bounded_like_percentage`	返回此目标是否在 0 到 1（含）之间有界。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`name`	返回描述目标的名称。
`objective_function`	根据指定的指标，计算提供的预测值与实际标签的相对值。
`perfect_score`	返回通过在完美模型上评估此目标获得的分数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`score_needs_proba`	返回一个布尔值，指示 score() 方法是否需要概率估计。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property expected_range(cls)#

返回目标的预期范围，这不一定是可能的范围。

例如，我们预期的 R2 范围是 [-1, 1]，尽管实际范围是 (-inf, 1]。

property greater_is_better(cls)#: 返回一个布尔值，指示更高的分数是否表示更好的模型性能。

property is_bounded_like_percentage(cls)#: 返回此目标是否在 0 到 1（含）之间有界。

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

property name(cls)#: 返回描述目标的名称。

abstract classmethod objective_function(cls, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

根据指定的指标，计算提供的预测值与实际标签的相对值。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

用于计算分数的数值

property perfect_score(cls)#: 返回通过在完美模型上评估此目标获得的分数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

property score_needs_proba(cls)#

返回一个布尔值，指示 score() 方法是否需要概率估计。

对于使用预测概率的目标（例如对数损失或 AUC），此应为 true；对于将预测类别标签与实际标签进行比较的目标（例如 F1 或相关性），此应为 false。

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.RootMeanSquaredError[source]#

回归的均方根误差。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(RootMeanSquaredError().objective_function(y_true, y_pred), 0.3988620)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	均方根误差
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	回归的均方根误差目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 回归的均方根误差目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.RootMeanSquaredLogError[source]#

回归的均方根对数误差。

仅对非负输入有效。否则将抛出 ValueError。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(RootMeanSquaredLogError().objective_function(y_true, y_pred), 0.13090204)

属性

expected_range	None
greater_is_better	False
is_bounded_like_percentage	False
name	均方根对数误差
perfect_score	0.0
problem_types	[ProblemTypes.REGRESSION, ProblemTypes.TIME_SERIES_REGRESSION, ProblemTypes.MULTISERIES_TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	时间序列回归的均方根对数误差目标函数。
`positive_only`	如果为 True，则此评估函数仅对正数数据有效。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 时间序列回归的均方根对数误差目标函数。

positive_only(self)#: 如果为 True，则此评估函数仅对正数数据有效。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。

class evalml.objectives.SensitivityLowAlert(alert_rate=0.01)[source]#

低警报率下的敏感性。

参数: alert_rate (float) – 将得分最高的百分比观测值归类为高风险。

属性

expected_range	[0, 1]
greater_is_better	True
is_bounded_like_percentage	True
name	低警报率下的敏感度
perfect_score	1.0
problem_types	[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`can_optimize_threshold`	返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。
`decision_function`	根据警报率确定观测值是否为高风险。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	计算所有预测的敏感度，使用得分最高的 alert_rate 百分比观测值作为预测的正类别。
`optimize_threshold`	学习优化当前目标的二元分类阈值。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	验证评分的输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

property can_optimize_threshold(cls)#

返回一个布尔值，指示我们是否可以优化二元分类目标的阈值。

对于直接处理预测概率（如对数损失和 AUC）的任何目标，这将为 false。否则，它将为 true。

返回: 目标是否可以优化。
返回类型: bool

decision_function(self, ypred_proba, **kwargs)[source]#

根据警报率确定观测值是否为高风险。

参数

ypred_proba (pd.Series) – 预测概率。
**kwargs – 额外的任意参数。

返回

根据警报率判断观测值是否为高风险。

返回类型

pd.Series

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, **kwargs)[source]#

计算所有预测的敏感度，使用得分最高的 alert_rate 百分比观测值作为预测的正类别。

参数

y_true (pd.Series) – 真实标签。
y_predicted (pd.Series) – 基于警报率的预测标签。
**kwargs – 额外的任意参数。

返回

使用得分最高的观测值作为预测的正类别，计算敏感度。

返回类型

float

optimize_threshold(self, ypred_proba, y_true, X=None)#

学习优化当前目标的二元分类阈值。

参数

ypred_proba (pd.Series) – 分类器的预测概率
y_true (pd.Series) – 预测的基本事实。
X (pd.DataFrame, optional) – 训练数据中所需的任何额外列。

返回

此目标的最佳阈值。

引发

RuntimeError – 如果目标无法优化。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#: 验证评分的输入。

class evalml.objectives.SMAPE[source]#

时间序列回归的对称平均绝对百分比误差。缩放 100 倍以返回百分比。

仅对非零输入有效。否则将抛出 ValueError。

示例

>>> y_true = pd.Series([1.5, 2, 3, 1, 0.5, 1, 2.5, 2.5, 1, 0.5, 2])
>>> y_pred = pd.Series([1.5, 2.5, 2, 1, 0.5, 1, 3, 2.25, 0.75, 0.25, 1.75])
>>> np.testing.assert_almost_equal(SMAPE().objective_function(y_true, y_pred), 18.13652589)

属性

expected_range	[0, 200]
greater_is_better	False
is_bounded_like_percentage	True
name	对称平均绝对百分比误差
perfect_score	0.0
problem_types	[ProblemTypes.TIME_SERIES_REGRESSION]
score_needs_proba	False

方法

`calculate_percent_difference`	计算分数之间的百分比差异。
`is_defined_for_problem_type`	返回目标是否为某个问题类型定义。
`objective_function`	时间序列回归的对称平均绝对百分比误差目标函数。
`positive_only`	如果为 True，则此目标仅对正向数据有效。默认为 False。
`score`	返回一个数值分数，指示基于预测值和实际值之间差异的性能。
`validate_inputs`	根据一些简单的检查验证输入。

classmethod calculate_percent_difference(cls, score, baseline_score)#

计算分数之间的百分比差异。

参数

score (float) – 一个分数。此目标评分方法的输出。
baseline_score (float) – 一个分数。此目标评分方法的输出。实际上，这是使用基线估计器在此目标上获得的分数。

返回

分数之间的百分比差异。注意，对于可以解释: 为百分比的目标，这将是参考分数和得分之间的差异。对于所有其他目标，差异将按参考分数进行归一化。

返回类型

float

classmethod is_defined_for_problem_type(cls, problem_type)#: 返回目标是否为某个问题类型定义。

objective_function(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)[source]#: 时间序列回归的对称平均绝对百分比误差目标函数。

positive_only(cls)#: 如果为 True，则此目标仅对正向数据有效。默认为 False。

score(self, y_true, y_predicted, y_train=None, X=None, sample_weight=None)#

返回一个数值分数，指示基于预测值和实际值之间差异的性能。

参数

y_predicted (pd.Series) – 长度为 [n_samples] 的预测值
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签
y_train (pd.Series) – 长度为 [n_samples] 的观察训练值
X (pd.DataFrame 或 np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame 或 np.ndarray) – 计算目标值结果时使用的样本权重

返回

score

validate_inputs(self, y_true, y_predicted)#

根据一些简单的检查验证输入。

参数

y_predicted (pd.Series 或 pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。

引发

ValueError – 如果输入格式错误。