sparkmllib源码分析之⼆分类逻辑回归的评价指标
在逻辑回归分类中，我们评价分类器好坏的主要指标有精准率（precision），召回率（recall），F-measure，AUC等，其中最常⽤的是AUC，它可以综合评价分类器性能，其他的指标主要偏重⼀些⽅⾯。我们介绍下spark中实现的这些评价指标，便于使⽤spark训练模型后，对训练结果进⾏评估。
1. 评价指标##
1.1. 混淆矩阵###
混淆矩阵(confusion matrix)⽤⼀张简单的表格，反应分类器对样本分类的情况
实际\预测10
1TP(True Positive)FN(Fla Negtive)
0FP(Fal Positive)TN(True Negtive)
0/1代表两类样本，下⾯解释下表格中的含义
珍珠母的功效与作用
TP：真阳性，预测是1，实际也是1
FP：假阳性，预测是1，实际是0
TN：真阴性，预测是0，实际也是0
FN：假阴性，预测是0，实际是1
不难看出，这个矩阵⼀条对⾓线上带T的是预测正确的样本（数量），另外⼀条对⾓线上带F的是预测错误的样本。
1.2. 基础指标
由这个矩阵，我们可以计算⼀系列衡量分类器性能的指标
准确率（Accuracy Rate）
分类器分对的样本在总样本中的⽐例
精准度（Precision）
真正的正样本在分类器分出的正样本中的⽐例召回率（Recall）
样本中正例被正确分类的⽐例
TPR（True Positive Rate），同召回率FPR（Fal Positive Rate）(T P+T N)/(T P+FP+T N+FN) T P/(T P+FP)⋯(1)
T P/(T P+FN)⋯(2)
被错误分成正例的样本在实际负例样本中的⽐例
1.3. F-measure
也称F-score，综合考虑precision和recall，经常⽤在信息检索中
当时，就是F1-score。的物理意义就是将准确率和召回率这两个分值合并为⼀个分值，在合并的过程中，召回率的权重是准确率的倍。分数认为召回率和准确率同等重要，分数认为召回率的重要程度是准确率的2倍，⽽分数认为召回率的重要程度是准确率的⼀半
1.4. ROC
样本经过分类器后，我们可以得到样本的预测值，以这些预测值为阈值，就可以得到这些预测值对应的的混淆矩阵，每个混淆矩阵都可以计
算(FPR, TPR)这样的点对，将这些点对绘制在⼆维坐标系中，然后连起来就得到了ROC曲线
显然坐标(1, 0)是所有正例全部分错，是最坏的情况，坐标(0, 1)是正例全部分对，是最好的情况，⽽这条线代表了随机猜测的情况，因此正常的分类器的ROC曲线应该是⾼于这条直线的。
1.5. AUC
ROC是条曲线，不⽅便我们对⽐分类器的好坏，因此我们⽤ROC覆盖的⾯积这样⼀个数值来衡量分类器，AUC的计算⽅法主要有两种，⼀种⽤相邻两点构成的等腰梯形近似计算，另外⼀种利⽤与Wilcoxon-Mann-Witney Test等价关系计算。
1.5.1. 直⾓梯形法
如1.3中的图所⽰，ROC曲线上的两个相邻点，以及它们在x轴上的投影构成了⼀个直⾓梯形，当两个点⾜够接近时，可以近似为两点之间曲线下的⾯积
将ROC曲线上的点依次组成这种对，连续计算相邻两点形成的直⾓梯形并累加即可得到近似的AUC值。
1.5.
2. Wilcoxon-Mann-Witney Test
FP /(FP +T N )⋯(3)
F =β⋯(4)
βP +R 2(β+1)PR
2β=1F ββF 1F 2F .50y =x (x 1,x 2),(y 1,y 2)s =(y 1−x 1)∗(x 2+y 2)/2⋯(5)
AUC和Wilcoxon-Mann-Witney Test是等价的，⽽Wilcoxon-Mann-Witney Test就是从样本中任意抽取
⼀个正例本和⼀个负例，正例⼤于负例score的概率。具体计算这个概率可以通过统计所有的 正负样本对(M N，M为正样本数量，N为负样本数量)中，正样本score⼤于负样本score的数量除以M N来近似。如果这个pair的正负样本 score相等，则按0.5计算，这个⽅法的复杂度为。在此基础上，还有种改进⽅法，具体做法是将所有样本按score从⼤到⼩逆序排序，然后取所有正样本的排序次序相加，
这种⽅法下，如果某正例s的次序是，则算上这个样本，⽐它score⼩的样本数量就是，s与这些样本组成的pair对中，再去掉⼩于等于它的正样本就是需要计算的负样本的个数，⽽这些需要去掉的正样本数量则是（对应最⼤score的正例），（对应score第⼆⼤的正例），依次类推，score最⼩的样本则对应1，也就是对应数列，其和是，分母上再除去即可。##2. 实现
2.1. BinaryLabelCounter
记录样本label的分布情况
private[evaluation] class BinaryLabelCounter(
var numPositives: Long = 0L,
var numNegatives: Long = 0L)
包含了正/负样本的数量
值得注意的是其运算中兼容了负例label为0/-1这两种情况，只要label⼩于等于0.5就认为是负例
def +=(label: Double): BinaryLabelCounter = {
if (label > 0.5) numPositives += 1L el numNegatives += 1L
this
}
2.2. confusion matrix
count是⼤于当前score的样本的label分布，totalCount是所有的label的分布
private[evaluation] ca class BinaryConfusionMatrixImpl(
count: BinaryLabelCounter,
totalCount: BinaryLabelCounter) extends BinaryConfusionMatrix {
/** TP */
大五人格模型
override def numTruePositives: Long = count.numPositives
/** FP */
override def numFalPositives: Long = count.numNegatives
/** FN */
override def numFalNegatives: Long = totalCount.numPositives - count.numPositives
/** TN */
override def numTrueNegatives: Long = totalCount.numNegatives - count.numNegatives
炒白萝卜丝
/** number of positives */
override def numPositives: Long = totalCount.numPositives
/** number of negatives */
override def numNegatives: Long = totalCount.numNegatives
}
2.3. 基础指标
包括precision，FPR，TPR(Recall)，F-score，这些指标都定义成object，继承⾃BinaryClassificationMetricComputer基类，然后实现apply函数，可以不显式使⽤new，⽽类似函数形式来计算，好处是⽤在⾼阶函数的参数列表中，可以根据需要传⼊需要计算的指标，⾮常灵活，参见BinaryClassificationMetrics中createCurve函数的⽤法，计算逻辑都⽐较直观简单。
2.3.1. precision
O ((M +N ))2r auc =⋯(6)
MN r −M (M +1)/2
∑positive i r k r k M M −1M ,M −1,...,1M (M +1)/2M ∗N
private[evaluation] object Precision extends BinaryClassificationMetricComputer {
override def apply(c: BinaryConfusionMatrix): Double = {
val totalPositives = c.numTruePositives + c.numFalPositives
if (totalPositives == 0) {
1.0
} el {
//式（1）
Double / totalPositives
}
}
}
2.3.2. FPR
private[evaluation] object FalPositiveRate extends BinaryClassificationMetricComputer {
override def apply(c: BinaryConfusionMatrix): Double = {
if (c.numNegatives == 0) {
0.0
} el {
//式(3)
Double / c.numNegatives
}
}
}
2.3.3. TPR(Recall)
private[evaluation] object Recall extends BinaryClassificationMetricComputer {
override def apply(c: BinaryConfusionMatrix): Double = {
if (c.numPositives == 0) {
0.0
} el {
//式(2)
Double / c.numPositives
}
}生日快乐英文怎么说
}
2.3.4. F-measure
private[evaluation] ca class FMeasure(beta: Double) extends BinaryClassificationMetricComputer {
private val beta2 = beta * beta
override def apply(c: BinaryConfusionMatrix): Double = {
val precision = Precision(c)
val recall = Recall(c)
if (precision + recall == 0) {
0.0
} el {
//式(4)
(1.0 + beta2) * (precision * recall) / (beta2 * precision + recall)
}
}
}
3. BinaryClassificationMetrics
计算样本的分布，构造ROC曲线，计算AUC等⼆分类评估指标
class BinaryClassificationMetrics @Since("1.3.0") (
@Since("1.3.0") val scoreAndLabels: RDD[(Double, Double)],
@Since("1.3.0") val numBins: Int)
类成员为含有预测值(score, label) pair对的样本rdd，numBins是⽤于计算ROC时的⽤的点数，当样本数远⼤于numBins时则抽样，相当于对样本score做等频离散化。
3.1. label分布与混淆矩阵
计算样本各score（预测值）的累积label分布cumulativeCounts与混淆矩阵confusions
private lazy val (
cumulativeCounts: RDD[(Double, BinaryLabelCounter)],
confusions: RDD[(Double, BinaryConfusionMatrix)]) = {
// Create a bin for each distinct score value, count positives and negatives within each bin,
// and then sort by score values in descending order.
//将具有相同预测值的样本累计在⼀起并按降序排序，key是预测值，value是BinaryLabelCounter，累计正样本和负样本的个数
val counts = bineByKey(
createCombiner = (label: Double) => new BinaryLabelCounter(0L, 0L) += label,
mergeValue = (c: BinaryLabelCounter, label: Double) => c += label,
mergeCombiners = (c1: BinaryLabelCounter, c2: BinaryLabelCounter) => c1 += c2
美发
).sortByKey(ascending = fal)
简笔画春节
//抽样并排序
val binnedCounts =
// Only down-sample if bins is > 0
if (numBins == 0) {
// U original directly
counts
} el {
val countsSize = unt()
// Group the iterator into chunks of about countsSize / numBins points,
// so that the resulting number of bins is about numBins
var grouping = countsSize / numBins
if (grouping < 2) {
// numBins was more than half of the size; no real point in down-sampling to bins
安全教育平台入口
logInfo(s"Curve is too small ($countsSize) for $numBins bins to be uful")
counts
} el {
//样本个数⼤于2倍numBins，抽样
if (grouping >= Int.MaxValue) {
logWarning(
s"Curve too large ($countsSize) for $numBins bins; capping at ${Int.MaxValue}")
grouping = Int.MaxValue
}
//grouped是将迭代器每grouping个组成⼀个新的迭代器，例如[i1, i2, i3,...,i100]，如果grouping为4，则[[i1,i2,i3,i4], [i5,i6,i7,i8], ...] counts.mapPartitions(_.Int).map { pairs =>
//取新组中的第⼀个分数为新的pair分数，相当于等频离散化
val firstScore = pairs.head._1
//累加组内的label计数
val agg = new BinaryLabelCounter()
pairs.foreach(pair => agg += pair._2)
纷纷落下//拼成新的pair，相当于抽样了
(firstScore, agg)
})
}
}
//按partition内累积
val agg = binnedCounts.values.mapPartitions { iter =>
val agg = new BinaryLabelCounter()
iter.foreach(agg += _)
Iterator(agg)
}.collect()
//part间累积
val partitionwiCumulativeCounts =
agg.scanLeft(new BinaryLabelCounter())((agg, c) => agg.clone() += c)
val totalCount = partitionwiCumulativeCounts.last
logInfo(s"Total counts: $totalCount")
//part内累积：每个score先整体累加前⼀个part，在累加part内其他score的
val cumulativeCounts = binnedCounts.mapPartitionsWithIndex(
(index: Int, iter: Iterator[(Double, BinaryLabelCounter)]) => {
val cumCount = partitionwiCumulativeCounts(index)
iter.map { ca (score, c) =>
cumCount += c
