如果您想弄清楚这个 ROC 是如何发生的，您最好列出包含“预测”值和“真实”值的元组，并使用“预测”值排序，然后绘制ROC。

在您的情况下，元组和点应该是这样的：

  predicted truth (x,y)
    0.53 0  (6/6,14/14)
    0.55 0  (5/6,14/14)
    0.57 1  (4/6,14/14)
    0.59 0  (4/6,13/14)
    0.60 1  (3/6,13/14)
    0.62 1  (3/6,12/14)
    0.63 0  (3/6,11/14)
    0.64 0  (2/6,11/14)
    0.66 1  (1/6,11/14)
    0.68 1  (1/6,10/14)
    0.71 1  (1/6,9/14)
    0.73 1  (1/6,8/14)
    0.77 1  (1/6,7/14)
    0.78 0  (1/6,6/14)
    0.82 1  (0/6,6/14)
    0.86 1  (0/6,5/14)
    0.89 1  (0/6,4/14)
    0.92 1  (0/6,3/14)
    0.94 1  (0/6,2/14)
    0.96 1  (0/6,1/14)
            (0/6,0/14)

将这些点 (x,y) 放在 ROC 图片上，应该是这样的：

就像你的一样！

顺便说一句，如果你想知道这些点是如何计算出来的，你可以查看下面用 scala 编写的代码：

    def computeAuc(predict: BDV[Double],groundTruth: BDV[Double]): Double
    = {
    
        // retrieve number of positive and negative samples in ground truth
        val nPos = groundTruth.toArray.filter(_>0).length
        val nNeg = groundTruth.toArray.filter(_<=0).length
    
        // tuple predict with ground truth , and sort with predict
        val pair = predict.toArray.zip(groundTruth.toArray)
        val sortedPair = pair.sortBy(_._1)
        var auc = 0.0.toDouble
        val x = BDV.zeros[Double](predict.length + 1)
        val y = BDV.zeros[Double](predict.length + 1)
        x(0) = 1.0
        y(0) = 1.0
    
        // calculate auc incrementally
        var i = 1.toInt
        while(i < sortedPair.length) {
          y(i) = (1.0 * sortedPair.slice(i,pair.length).filter(_._2 > 0).length) / nPos
          x(i) = (1.0 * sortedPair.slice(i,pair.length).filter(_._2 <= 0).length) / nNeg
          auc = auc + (((y(i) + y(i - 1))*(x(i - 1) - x(i)))/2.0)
          i += 1
        }
        auc = auc + ((y(i - 1) * x(i - 1))/2.0)
    
        auc
   }

最后，你的不平衡问题很严重，你最好在训练前进行下采样或上采样。

希望这对您有所帮助，祝您好运-)

AUC 基于您的预测的排名顺序，而不是分配给它的实际类别。输出的规模很可能行为不端。

看看你的预测值，我怀疑你的模型的预测在一个狭窄的范围内。如果是这种情况， argmax 将为您的所有观察结果产生相同的类（这就是正在发生的事情）。

您可能希望修改一些超参数，以查看究竟是哪一个导致了这种情况（可能从学习率开始）。如果逻辑回归给您带来相同的问题，这可能值得测试，这将有助于确定您的输入/特征是否存在问题。