standard_metrics#
标准机器学习目标函数。
模块内容#
类摘要#
二元分类的准确率分数。 |
|
多元分类的准确率分数。 |
|
二元分类的AUC分数。 |
|
使用宏平均法的多元分类AUC分数。 |
|
使用微平均法的多元分类AUC分数。 |
|
使用加权平均法的多元分类AUC分数。 |
|
二元分类的平衡准确率分数。 |
|
多元分类的平衡准确率分数。 |
|
回归的解释方差分数。 |
|
二元分类的F1分数。 |
|
使用宏平均法的多元分类F1分数。 |
|
使用微平均法的多元分类F1分数。 |
|
使用加权平均法的多元分类F1分数。 |
|
二元分类的基尼系数。 |
|
二元分类的对数损失。 |
|
多元分类的对数损失。 |
|
回归的平均绝对误差。 |
|
时间序列回归的平均绝对百分比误差。缩放100倍以返回百分比。 |
|
时间序列回归的平均绝对比例误差。 |
|
回归的最大残差误差。 |
|
二元分类的马修斯相关系数。 |
|
多元分类的马修斯相关系数。 |
|
回归的均方对数误差。 |
|
回归的中位数绝对误差。 |
|
回归的均方误差。 |
|
二元分类的精确率分数。 |
|
使用宏平均法的多元分类精确率分数。 |
|
使用微平均法的多元分类精确率分数。 |
|
使用加权平均法的多元分类精确率分数。 |
|
回归的决定系数。 |
|
二元分类的召回率分数。 |
|
使用宏平均法的多元分类召回率分数。 |
|
使用微平均法的多元分类召回率分数。 |
|
使用加权平均法的多元分类召回率分数。 |
|
回归的均方根误差。 |
|
回归的均方根对数误差。 |
|
时间序列回归的对称平均绝对百分比误差。缩放100倍以返回百分比。 |
目录#
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
二元分类准确率分数的客观函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多元分类准确率分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
二元分类 AUC 分数的客观函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
使用宏平均法的多元分类 AUC 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
使用微平均法的多元分类 AUC 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
使用加权平均法的多元分类 AUC 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
二元分类平衡准确率分数的客观函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多元分类平衡准确率分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
回归的解释方差分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
二元分类 F1 分数的客观函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
使用宏平均法的多元分类 F1 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多元分类 F1 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
使用加权平均法的多元分类 F1 分数的客观函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
二元分类基尼系数的客观函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
用于二分类的对数损失目标函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于多分类的对数损失目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的平均绝对误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于时间序列回归的平均绝对百分比误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于时间序列回归的平均绝对标度误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的最大残差误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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 二分类
perfect_score
1.0
problem_types
[ProblemTypes.BINARY, ProblemTypes.TIME_SERIES_BINARY]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
用于二分类的 Matthews 相关系数目标函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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 多分类
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于多分类的 Matthews 相关系数目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的均方对数误差目标函数。
如果为 True，则此目标仅对正数数据有效。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的中位数绝对误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的均方误差目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
用于二分类的精确率目标函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
Precision Macro（宏平均精确率）
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于多分类的宏平均精确率目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
Precision Micro（微平均精确率）
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于多分类的微平均精确率目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
Precision Weighted（加权平均精确率）
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于多分类的加权平均精确率目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
用于回归的决定系数目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回一个布尔值，表示我们是否可以优化二元分类目标函数的阈值。
将学习到的阈值应用于预测概率以获得预测类别。
返回目标函数是否针对特定问题类型定义。
用于二分类的召回率目标函数。
学习一个优化当前目标函数的二元分类阈值。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
验证评分的输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
验证评分的输入。
- class evalml.objectives.standard_metrics.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
宏观召回率
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多分类中，使用宏观平均计算召回率的目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
微观召回率
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多分类中，使用微观平均计算召回率的目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
加权召回率
perfect_score
1.0
problem_types
[ProblemTypes.MULTICLASS, ProblemTypes.TIME_SERIES_MULTICLASS]
score_needs_proba
False
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
多分类中，使用加权平均计算召回率的目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
回归问题中，用于计算均方根误差的目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
回归问题中，用于计算均方根对数误差的目标函数。
如果为 True，则此目标仅对正数数据有效。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。
- class evalml.objectives.standard_metrics.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
方法
计算分数之间的百分比差异。
返回目标函数是否针对特定问题类型定义。
时间序列回归中，用于计算对称平均绝对百分比误差的目标函数。
如果为 True，则此目标函数仅对正向数据有效。默认为 False。
返回一个数值分数，表示基于预测值与实际值之间差异的性能。
根据一些简单检查验证输入。
- 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 or np.ndarray) – 计算分数所需的形状为 [n_samples, n_features] 的额外数据
sample_weight (pd.DataFrame or np.ndarray) – 用于计算目标值结果的样本权重
- 返回值
score
- validate_inputs(self, y_true, y_predicted)#
根据一些简单检查验证输入。
- 参数
y_predicted (pd.Series, or pd.DataFrame) – 长度为 [n_samples] 的预测值。
y_true (pd.Series) – 长度为 [n_samples] 的实际类别标签。
- 抛出
ValueError – 如果输入格式错误。