模型性能评估在机器学习中是不可或缺的环节,下面总结了sklearn中比较常用的。
设计时为了统一规则,scoring
都是越大越好,像metrics.mean_squared_error
是取它的负值neg_mean_squared_error
。
Classification
accuracy
精确度的计算公式为
\[accuracy(y,\hat{y})=\frac{1}{n_{samples}} \sum_{i=0}^{n_{samples}-1} I(\hat{y_i}=y_i)\]\(\hat{y_i}\)是第i个样本的预测值,\(y_i\)是第i个样本的真实值,I
是指示函数。
它的原理很简单,就是预测正确的占全体样本的比率。
在sklearn中accuracy_score
可以很好实现它。
import numpy as np
from sklearn.metrics import accuracy_score
y_pred = [0, 2, 1, 3]
y_true = [0, 1, 2, 3]
print('the correctly classified samples: ',accuracy_score(y_true, y_pred))
print('the number of correctly classified samples: ',accuracy_score(y_true, y_pred, normalize=False))
代码运行结果
the correctly classified samples: 0.5
the number of correctly classified samples: 2
当normalize=True
时,返回值是正确分类占全体样本的比值,当normalize=False
时,返回值是正确分类的数目。
也是可以处理多分类问题。
print(accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2))))
代码运行结果
0.5
Cohen’s kappa
Cohen’s kappa系数作为评价判断的一致性程度的指标。
\[k\equiv \frac{p_0-p_e}{1-p_e}\]其中\(p_o\)在给任何样本的标签上达成一致的经验概率,\(p_e\)是随机分配标签时预期的概率。
下面是Wikipedia的例子
有50个人申请拨款,2个人审批,只可以说yes或者no
B | |||
Yes | No | ||
A | Yes | a | b |
No | c | d |
等价于
B | |||
Yes | No | ||
A | Yes | 20 | 5 |
No | 10 | 15 |
根据Cohen’s kappa系数公式
\(p_0=\frac{a+d}{a+b+c+d}=\frac{20+15}{50}=0.7\)
\(p_{Yes}=\frac{a+b}{a+b+c+d}\cdot \frac{a+c}{a+b+c+d}=0.5\ast 0.6=0.3\)
\(p_{No}=\frac{c+d}{a+b+c+d}\cdot \frac{b+d}{a+b+c+d}=0.5\ast 0.4=0.2\)
\(p_e=p_{Yes}+p_{No}=0.3+0.2=0.5 \)
\( k=\frac{p_0-p_e}{1-p_e}=\frac{0.7-0.5}{1-0.5}=0.4\)
可以用sklearn中cohen_kappa_score
来实现。
from sklearn.metrics import cohen_kappa_score
y_true = [1, 0, 1, 1, 0, 1]
y_pred = [1, 1, 1, 1, 0, 0]
print('Cohen's kappa coefficient: 'cohen_kappa_score(y_true, y_pred))
代码运行结果
ohen's kappa coefficient: 0.25
Confusion matrix
在机器学习中,有一个普遍适用的称为混淆矩阵(confusion matrix)的工具,它可以帮助人们更好地了解分类中的错误。
有这样一个关于在房子周围可能发现的动物类型的预测,这个预测的三类问题的混淆矩阵如下表所示。
Actual class | ||||
---|---|---|---|---|
Cat | Dog | Rabbit | ||
Predicted
class |
Cat | 5 | 2 | 0 |
Dog | 3 | 3 | 2 | |
Rabbit | 0 | 1 | 11 |
利用混淆矩阵就可以更好的理解分类中的错误了。如果矩阵中的非对角线元素均为0,就会得到完美的分类器。
为简化处理,我们可以考虑另外一个混淆矩阵,该矩阵只针对一个简单的二类问题。在这个二类问题中,如果将一个正例判为正例,那么就可以认为产生了一个真正例(True Positive,TP,也称真阳),如果对一个反例正确的判为反例,则认为产生了一个真反例(True Negative,TN,也称真阴)。相应的,另外两种情况则分别称为伪反例(False Negative,FN,也称假阴)和伪正例(False Positive,FP,也称假阳),如下表所示。
Actual class | ||||
---|---|---|---|---|
Cat | Non-cat | |||
Predicted
class |
Cat | 5 True Positives | 2 False Positives | |
Non-cat | 3 False Negatives | 17 True Negatives |
在分类中,当某个类别的重要性高于其他类别时,我们就可以利用上述定义来定义出多个比错误率更好的新指标。其中使用较多的有精确率(Precision),召回率(Recall),F1分数(F1-score)
\(Precision=\frac{TP}{TP+FP}\)
\(Recall=\frac{TP}{TP+FN}\)
\(F1-score=\frac{2}{\frac{1}{Recall}+\frac{1}{Precision}}=2\cdot \frac{Precision\cdot Recall}{Precision+Recall}\)
\(F_{\beta}-score=(1+\beta^2)\cdot \frac{Precision\cdot Recall}{(\beta^2\cdot Precision)+Recall}\)
skearn的confusion_matrix
用来计算混淆矩阵。
from sklearn.metrics import confusion_matrix
y_true = [2, 0, 2, 2, 0, 1]
y_pred = [0, 0, 2, 2, 0, 2]
print(confusion_matrix(y_true, y_pred))
代码运行结果
[[2 0 0]
[0 0 1]
[1 0 2]]
对于二分类问题,我们可以计算出TN,FP,FN,TP。
y_true = [0, 0, 0, 1, 1, 1, 1, 1]
y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
print(tn, fp, fn, tp)
代码运行结果
2 1 2 3
Classification report
classification_report
可以展现主要分类指标,包括上面说的Precision,Recall,F1-score。
from sklearn.metrics import classification_report
y_true = [0, 1, 2, 2, 0]
y_pred = [0, 0, 2, 1, 0]
target_names = ['class 0', 'class 1', 'class 2']
print(classification_report(y_true, y_pred, target_names=target_names))
代码运行结果
precision recall f1-score support
class 0 0.67 1.00 0.80 2
class 1 0.00 0.00 0.00 1
class 2 1.00 0.50 0.67 2
avg / total 0.67 0.60 0.59 5
其中Support代表每个类别的样本数,最下面一行是根据support的加权值。precision=(0.672+0.001+1.00*2)/5=0.67,recall和f1-score类似。
Hamming loss
hamming_loss
计算两个样本之间额Hamming距离。
其中,\(\hat{y_j}\)是第j个样本的预测值,\(y_j\)是第j个样本的真实值,\(n_{labels}\)是标签总数,I(x)是指示函数。
sklearn中的实现
from sklearn.metrics import hamming_loss
y_pred = [1, 2, 3, 4]
y_true = [2, 2, 3, 4]
print(hamming_loss(y_true, y_pred))
代码运行结果
0.25
在二分类的多标签问题中
print(hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2))))
代码运行结果
0.75
Jaccard similarity coefficient score
Jaccard指数是用来比较样本集的相似性和多样性的统计数据,它的公式:
\[J(y_i,\hat{y_i})=\frac{|y_i\bigcap \hat{y_i}|}{|y_i\bigcup \hat{y_i}|}\]其中,\(\hat{y_j}\)是第j个样本的预测值,\(y_j\)是第j个样本的真实值。
在二分类和多分类问题中
import numpy as np
from sklearn.metrics import jaccard_similarity_score
y_pred = [0, 2, 1, 3]
y_true = [0, 1, 2, 3]
print(jaccard_similarity_score(y_true, y_pred))
print(jaccard_similarity_score(y_true, y_pred, normalize=False))
代码运行结果
0.5
2
在二分类多标签问题中
print(jaccard_similarity_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2))))
代码运行结果
0.75
Precision, recall and F-measures
前面在混淆矩阵有讲过这些指标。
- precision是被分为正例的示例中实际为正例的比例
- recall是实际为正例的示例中预测为正例的比例。
- F-measure是precision和recall的加权平均
其中precision和recall的偏重应该视具体情况,比如查找涉黄读物,那我们应该更希望recall更高,因为这样可以找出更多的危害读物,尽管可能会误杀更多没问题的读物。下面列出了sklearn中计算上述指标的函数。
需要注意的是precision_recall_curve
值只可以用于二元问题,average_precision_score只可以在二分类多标签的问题。
在二分类问题中
import numpy as np
from sklearn import metrics
y_pred = [0, 1, 0, 0]
y_true = [0, 1, 0, 1]
print('precision_score:',metrics.precision_score(y_true, y_pred))
print('recall_score:',metrics.recall_score(y_true, y_pred))
print('f1_score:',metrics.f1_score(y_true, y_pred))
print('fbeta_score:',metrics.fbeta_score(y_true, y_pred, beta=0.5))
print('fbeta_score:',metrics.fbeta_score(y_true, y_pred, beta=1))
print('fbeta_score:',metrics.fbeta_score(y_true, y_pred, beta=2))
print('precision_recall_fscore_support:',metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5))
y_true = np.array([0, 0, 1, 1])
y_scores = np.array([0.1, 0.4, 0.35, 0.8])
precision, recall, threshold = metrics.precision_recall_curve(y_true, y_scores)
print('precision:',precision)
print('recall:',recall)
print('threshold:',threshold)
print(metrics.average_precision_score(y_true, y_scores))
代码运行结果
precision_score: 1.0
recall_score: 0.5
f1_score: 0.6666666666666666
fbeta_score: 0.8333333333333334
fbeta_score: 0.6666666666666666
fbeta_score: 0.5555555555555556
precision_recall_fscore_support: (array([0.66666667, 1. ]), array([1. , 0.5]), array([0.71428571, 0.83333333]), array([2, 2], dtype=int64))
precision: [0.66666667 0.5 1. 1. ]
recall: [1. 0.5 0.5 0. ]
threshold: [0.35 0.4 0.8 ]
average_precision_score: 0.8333333333333333
在多分类和多标签分类中
- y是预测(sample,label)的集合
- \(\hat{y}\)是真实(sample,label)的集合
- L是标签的集合
- S是样本的集合
- \(y_s\)是样本s的子集,\(y_s:={(s’,l)\in y | s’=s }\)
- \(y_l\)是标签为l的y的子集
- 相似的,\(\hat{y_s}\)和\(\hat{y_l}\)是\(\hat{y}\)的子集
- \(P(A,B):=\frac{|A \bigcap B|}{|A|}\)
- \(R(A,B):= \frac{|A \bigcap B|}{|A|} \)
- \(F_{\beta}(A,B):=(1+\beta^2)\frac{P(A,B)\cdot R(A,B)}{\beta^2\cdot P(A,B)+R(A,B)}\)
from sklearn import metrics
y_true = [0, 1, 2, 0, 1, 2]
y_pred = [0, 2, 1, 0, 0, 1]
print('precision_score:',metrics.precision_score(y_true, y_pred, average='macro'))
print('recall_score:',metrics.recall_score(y_true, y_pred, average='micro'))
print('f1_score:',metrics.f1_score(y_true, y_pred, average='weighted'))
print('fbeta_score:',metrics.fbeta_score(y_true, y_pred, average='macro', beta=0.5))
print('precision_recall_fscore_support:',metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5, average=None))
print('recall_score:',metrics.recall_score(y_true, y_pred, labels=[1, 2], average='micro'))
print('precision_score:',metrics.precision_score(y_true, y_pred, labels=[0, 1, 2, 3], average='macro'))
代码运行结果
precision_score: 0.2222222222222222
recall_score: 0.3333333333333333
f1_score: 0.26666666666666666
fbeta_score: 0.23809523809523805
precision_recall_fscore_support: (array([0.66666667, 0. , 0. ]), array([1., 0., 0.]), array([0.71428571, 0. , 0. ]), array([2, 2, 2], dtype=int64))
recall_score: 0.0
precision_score: 0.16666666666666666
Hinge loss
在机器学习中,Hinge loss是训练分类的一种损失函数,它是被使用在最大边缘分类,尤其是在支持向量机(SVMs)中。
若标签为+1或-1,y是真实值,w是决策函数的输出值,这时Hinge loss如下面公式:
\[L_{Hinge}(y,w)=max\{0,1-wy\}=|1-wy|_{+}\]对于多分类问题,公式如下:
\[L_{Hinge}(y_w,y_t)=max\{1+y_t-y_w,0\}\]使用hinge_loss
在一个解决二分类问题的svm算法中
from sklearn import svm
from sklearn.metrics import hinge_loss
X=[[0],[1]]
y=[-1,1]
est=svm.LinearSVC(random_state=0)
est.fit(X,y)
pre_decision=est.decision_function([[-2],[3],[0.5]])
print('pre_decision:',pre_decision)
print('hinge_loss:',hinge_loss([-1,1,1],pre_decision))
代码运行结果
pre_decision: [-2.18177262 2.36361684 0.09092211]
hinge_loss: 0.3030259636876493
hinge_loss
在多分类svm分类器中
import numpy as np
from sklearn import svm
from sklearn.metrics import hinge_loss
X=np.array([[0],[1],[2],[3]])
y=np.array([0,1,2,3])
labels=np.array([0,1,2,3])
est=svm.LinearSVC()
est.fit(X,y)
pre_decision=est.decision_function([[-1],[2],[3]])
y_true=[0,2,3]
print('hinge_loss:',hinge_loss(y_true,pre_decision,labels))
代码运行结果
hinge_loss: 0.5641094289148848
Log loss
Log loss也被叫做逻辑回归损失函数或者交叉熵损失函数。它通常被使用在逻辑回归和神经网络中。
对于二分类,\(y\in {0,1}\),\(p=Pr(y=1)\),公式如下:
\[L_{log}(y,p)=-logPr(y|p)=-(ylog(p)+(1-y)log(1-p))\]也可以用于多分类问题,K是表示一共有K个标签,k是K个标签中的第k个,\(y_{i,k}\)是样本i有标签k,\(p_{i,k}=Pr(t_{i,k}=1)\),公式如下
\[L_{log}(Y,P)=-logPr(Y|P)=-\frac{1}{N}\sum_{i=0}^{N-1}\sum_{k=0}^{K-1}y_{i,k}logp_{i,k}\]log_loss
是根据真实值和预测可能概率来计算log loss。
from sklearn.metrics import log_loss
y_true=[0,0,1,1]
y_pred=[[.9,.1],[.8,.2],[.3,.7],[.01,.99]]
print('log_loss:',log_loss(y_true,y_pred))
代码运行结果
log_loss: 0.1738073366910675
Matthews correlation coefficient
本质上,MCC是观察和预测的二元分类之间的一个相关系数,它返回-1到1之间,其中+1代表完美的预测,0代表和随机预测一样,-1代表预测值和真实值完全相反。
MCC可以直接用前面所讲的混淆矩阵计算,如下:
\[MCC=\frac{tp\times tn-fp\times fn}{\sqrt{(tp+fp)(tp+fn)(tn+fp)(tn+fn)}}\]在多分类问题中,K个不同类,混淆矩阵C为KxK
- \(t_k=\sum_i^K C_{ik}\) 第k类真实出现的次数
- \(p_k=\sum_i^K C_{ki}\) 第k类预测出现的次数
- \(c=\sum_k^K C_{kk}\) 样本被正确预测的总数
- \(s=\sum_i^K\sum_j^K C_{ij}\) 样本总数
下面是一个简单的例子
from sklearn.metrics import matthews_corrcoef
y_true=[+1,+1,+1,-1]
y_pred=[+1,-1,+1,+1]
print('matthews_corrcoef:',matthews_corrcoef(y_true,y_pred))
代码运行结果
matthews_corrcoef: -0.3333333333333333
Receiver operating characteristic (ROC)
ROC曲线可以表明分类系统的性能。它是由不同的阈值设置绘制TPR和FPR而成,其中\(TPR=\frac{TP}{TP+FN}\),\(FPR=\frac{FP}{FP+TN}\)。图形越靠近左上角,说明性能越好。
下面是使用roc_curve
的实例
import numpy as np
from sklearn.metrics import roc_curve
y=np.array([1,1,2,2])
scores=np.array([0.1,0.4,0.35,0.8])
fpr,tpr,thresholds=roc_curve(y,scores,pos_label=2)
print('fpr:',fpr)
print('tpr:',tpr)
print('thresholds:',thresholds)
代码运行结果
fpr: [0. 0.5 0.5 1. ]
tpr: [0.5 0.5 1. 1. ]
thresholds: [0.8 0.4 0.35 0.1 ]
下图也是ROC曲线的例子
一个特定类的ROC曲线
多分类的ROC曲线
Zero one loss
0-1分类的损失函数在全样本的汇总值或者平均值。当设置normalize=False
时,\(L_{0-1}\)求汇总值。
其中\(I(X)\)是指示函数。
from sklearn.metrics import zero_one_loss
y_pred=[1,2,3,4]
y_true=[2,2,3,4]
print('the average:',zero_one_loss(y_true,y_pred))
print('the sum:',zero_one_loss(y_true,y_pred,normalize=False))
代码运行结果
the average: 0.25
the sum: 1
多标签也是类似,如下:
import numpy as np
from sklearn.metrics import zero_one_loss
print('the average:',zero_one_loss(np.array([[0,1],[1,1]]),np.ones((2,2))))
print('the sum:',zero_one_loss(np.array([[0,1],[1,1]]),np.ones((2,2)),normalize=False))
代码运行结果
the average: 0.5
the sum: 1
Brier score loss
Brier score是用来度量概率预测的正确率。Brier score loss是在0到1之间,值越小说明预测越正确。
\[BS=\frac{1}{N}\sum_{t=1}^N(f_t-o_t)^2\]其中N是预测的总样本数,\(f_t\)是预测概率,\(o_t\)是实际输出值。
import numpy as np
from sklearn.metrics import brier_score_loss
y_true=np.array([0,1,1,0])
y_true_categorical=np.array(['spam','ham','ham','spam'])
y_prob=np.array([0.1,0.9,0.8,0.4])
y_pred=np.array([0,1,1,0])
print('brier score:',brier_score_loss(y_true,y_prob))
print('brier score:',brier_score_loss(y_true,1-y_prob,pos_label=0))
print('brier score:',brier_score_loss(y_true_categorical,y_prob,pos_label='ham'))
print('brier score of y_prob>0.5:',brier_score_loss(y_true,y_prob>0.5))
代码运行结果
brier score: 0.055
brier score: 0.055
brier score: 0.055
brier score of y_prob>0.5: 0.0
前3个brier_score_loss
是等价的,pos_label
是指定以哪个为1,最后一个brier_score_loss
也可以写成brier_score_loss(y_true,=np.array([0,1,1,0]))
,可以发现,直接求accuracy的效果并不好,但是求概率可以更加精确,当然前提可以提供预测概率。
Multilabel ranking metrics
多标签问题有以下几种方法来测试性能。
Coverage error
Coverage error是计算实际标签所对应的概率标签,该概率标签在预测样本的多标签排序的序号,再求平均值。
\[coverage(y,\hat{f})=\frac{1}{n_{samples}}\sum_{i=0}{n_{samples}-1}max_{j:y_{ij}=1}rank_{ij}\] \[with \quad rank_{ij}=|\{k:\hat{f_{ik}}\geqslant \hat{f_{ij}} \}|\]coverage_error
实现
import numpy as np
from sklearn.metrics import coverage_error
y_true=np.array([[1,0,0],[0,0,1]])
y_score=np.array([[0.75,0.5,1],[1,0.2,0.1]])
print('coverage_error:',coverage_error(y_true,y_score))
代码运行结果
coverage_error: 2.5
上面代码是先找出y_true
中的1,然后找到y_score
对应的[[0.75],[0.1]],然后它们在各自排序的序号[[3],[2]],然后求均值(3+2)/2=2.5。
Label ranking average precision
label_ranking_average_precision_score
计算实际标签的平均精度。
下面是个小例子
import numpy as np
from sklearn.metrics import label_ranking_average_precision_score
y_true=np.array([[1,0,0],[0,0,1]])
y_score=np.array([[0.75,0.5,1],[1,0.2,0.1]])
print('label_ranking_average_precision_score:',label_ranking_average_precision_score(y_true,y_score))
代码运行结果
label_ranking_average_precision_score: 0.41666666666666663
上面例子中,首先\(rank_{ij}\)求法和Coverage error
一样,分别是[[2],[3]],\(L_{ij}\)分别是[[1],[1]],对应着[[0.75],[0.1]],然后求平均值\(\frac{\frac{1}{2}+\frac{1}{3}}{2}\approx 0.416\)。
Ranking loss
python实现
import numpy as np
from sklearn.metrics import label_ranking_loss
y_true=np.array([[1,0,0],[0,0,1]])
y_score=np.array([[0.75,0.5,1],[1,0.2,0.1]])
print('label_ranking_loss1:',label_ranking_loss(y_true,y_score))
y_score=np.array([[1.0,0.1,0.2],[0.1,0.2,0.9]])
print('label_ranking_loss2:',label_ranking_loss(y_true,y_score))
代码运行结果
label_ranking_loss1: 0.75
label_ranking_loss2: 0.0
Regression
回归比较简单,简略介绍下。
Explained variance score
explained variation是用来度量一个数据模型对给定数据集的变化(分散)的比例。可以用下面公式估计:
\[explained\_variance(y,\hat{y})=1-\frac{Var\{y-\hat{y}\}}{Var\{y\}}\]其中最好的分数是1,越小越差。
实例如下:
import numpy as np
from sklearn.metrics import explained_variance_score
y_true=[3,-0.5,2,7]
y_pred=[2.5,0.0,2,8]
print('explained_variance_score1:',explained_variance_score(y_true,y_pred))
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
print('explained_variance_score2:',explained_variance_score(y_true, y_pred, multioutput='raw_values'))
print('explained_variance_score3:',explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7]))
代码运行结果
explained_variance_score1: 0.9571734475374732
explained_variance_score2: [0.96774194 1. ]
explained_variance_score3: 0.9903225806451612
Mean absolute error
MAE是2个连续变量之间的差值。
\[MAE(y,\hat{y})=\frac{1}{n_{samples}}\sum_{i=0}^{n_{samples}-1}|y_i-\hat{y_i}|\]其中\(n_{samples}\)是样本数量,\(y_i\)第i个样本的正确值,\(\hat{y_i}\)是第i个样本的预测值。
sklearn中mean_absolute_error
来进行计算
from sklearn.metrics import mean_absolute_error
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
print('mean_absolute_error1:',mean_absolute_error(y_true, y_pred))
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
print('mean_absolute_error2:',mean_absolute_error(y_true, y_pred))
print('mean_absolute_error3:',mean_absolute_error(y_true, y_pred, multioutput='raw_values'))
print('mean_absolute_error4:',mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]))
代码运行结果
mean_absolute_error1: 0.5
mean_absolute_error2: 0.75
mean_absolute_error3: [0.5 1. ]
mean_absolute_error4: 0.85
Mean squared error
MSE是用来评估估计值质量。公式如下:
\[MSE(y,\hat{y})\sum_{i=0}^{n_{samples}-1}(y_i-\hat{y_i})^2\]使用mean_squared_error
实现
from sklearn.metrics import mean_squared_error
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
print('mean_squared_error:',mean_squared_error(y_true, y_pred))
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
print('mean_squared_error:',mean_squared_error(y_true, y_pred))
代码运行结果
mean_squared_error: 0.375
mean_squared_error: 0.7083333333333334
Mean squared logarithmic error
MSLE和MSE类似,不过先取np.log1p
,然后再进行MSE。
mean_squared_log_error
实现
from sklearn.metrics import mean_squared_log_error
y_true = [3, 5, 2.5, 7]
y_pred = [2.5, 5, 4, 8]
print('mean_squared_log_error1:',mean_squared_log_error(y_true, y_pred))
y_true = [[0.5, 1], [1, 2], [7, 6]]
y_pred = [[0.5, 2], [1, 2.5], [8, 8]]
print('mean_squared_log_error2:',mean_squared_log_error(y_true, y_pred))
代码运行结果
mean_squared_log_error1: 0.03973012298459379
mean_squared_log_error2: 0.044199361889160536
Median absolute error
中位绝对误差是对异常值有很好的鲁棒性。它是所有正确标签和估计标签的差值的绝对值,然后对这些绝对值求中位数。
\[MedAE(y,\hat{y})=median(|y_1-\hat{y_1}|,...,|y_n-\hat{y_n}|)\]median_absolute_error
实现
from sklearn.metrics import median_absolute_error
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
print('median_absolute_error:',median_absolute_error(y_true, y_pred))
代码运行结果
median_absolute_error: 0.5
R² score, the coefficient of determination
R² score是可以度量模型预测未知样本的性能。R² score为1最好,也可以为负数。当是一个常数模型,对于任何的输入值,总是可以得到预测值y,那么R² score为0.
\[R^2 (y,\hat{y})=1-\frac{\sum_{i=0}^{n_{samples}-1} (y_i-\hat{y_i})^2}{\sum_{i=0}^{n_{samples}-1} (y_i-\hat{y})^2}\] \[where \quad \overline{y}=\frac{1}{n_{samples}} \sum_{i=0}^{n_{samples}} y_i\]r2_score
实现
from sklearn.metrics import r2_score
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
print('r2_score1:',r2_score(y_true, y_pred))
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
print('r2_score2:',r2_score(y_true, y_pred, multioutput='variance_weighted'))
y_true = [[0.5, 1], [-1, 1], [7, -6]]
y_pred = [[0, 2], [-1, 2], [8, -5]]
print('r2_score3:',r2_score(y_true, y_pred, multioutput='uniform_average'))
print('r2_score4:',r2_score(y_true, y_pred, multioutput='raw_values'))
print('r2_score5:',r2_score(y_true, y_pred, multioutput=[0.3, 0.7]))
代码运行结果
r2_score1: 0.9486081370449679
r2_score2: 0.9382566585956417
r2_score3: 0.9368005266622779
r2_score4: [0.96543779 0.90816327]
r2_score5: 0.9253456221198156
未完待续。