ML System Evaluation and Metrics Questions

def roc_auc_score_manual(y_true, y_score):
    """
    Compute ROC AUC using ranking / trapezoidal rule without sklearn.
    y_true: iterable of 0/1 labels
    y_score: iterable of scores/probabilities (higher => positive)
    Returns: float AUC
    """
    # Convert to lists
    y_true = list(y_true)
    y_score = list(y_score)
    if len(y_true) == 0:
        raise ValueError("Empty inputs")
    if len(y_true) != len(y_score):
        raise ValueError("y_true and y_score must have same length")

    # Count positives and negatives
    P = sum(1 for y in y_true if y == 1)
    N = len(y_true) - P
    if P == 0 or N == 0:
        # AUC is undefined when only one class; return NaN or 0.5 by convention
        return float('nan')

    # Pair and sort by score descending
    paired = sorted(zip(y_score, y_true), key=lambda x: (-x[0], -x[1]))
    # Walk grouping ties to avoid artificial zig-zags
    tps = [0.0]  # cumulative true positives
    fps = [0.0]  # cumulative false positives
    i = 0
    while i < len(paired):
        score = paired[i][0]
        # aggregate group with same score
        tp_inc = 0
        fp_inc = 0
        while i < len(paired) and paired[i][0] == score:
            if paired[i][1] == 1:
                tp_inc += 1
            else:
                fp_inc += 1
            i += 1
        tps.append(tps[-1] + tp_inc)
        fps.append(fps[-1] + fp_inc)

    # Convert to rates
    tpr = [tp / P for tp in tps]
    fpr = [fp / N for fp in fps]

    # Trapezoidal integration over FPR (ensure monotonic)
    auc = 0.0
    for k in range(1, len(fpr)):
        x0, x1 = fpr[k-1], fpr[k]
        y0, y1 = tpr[k-1], tpr[k]
        auc += (x1 - x0) * (y0 + y1) / 2.0
    return auc