当所有模型都具有相似的准确度时，现在会怎样？

你已经训练了多个分类模型，它们似乎都表现良好，准确率很高。

但是一个模型真的比其他模型更好吗？单凭准确度并不能说明全部情况。如果一个模型一直高估其置信度，而另一个模型低估了它，该怎么办？这就是模型校准的作用所在。

在这里，我们将了解什么是模型校准，并探索如何评估模型预测的可靠性——使用视觉效果和实际代码示例向你展示如何识别校准问题。准备好超越准确性，发挥机器学习模型的真正潜力！

了解校准

模型校准衡量的是模型的预测概率与其实际性能之间的匹配程度。一个给出70%概率评分的模型，在类似预测中应有70%的时间是正确的。这意味着其概率评分应反映预测正确的真实可能性。

校准为何重要

准确率告诉我们模型整体正确的频率，而校准则告诉我们是否可以信任其概率评分。两个模型可能都具有90%的准确率，但其中一个可能给出真实的概率评分，而另一个则可能给出过于自信的预测。在许多实际应用中，拥有可靠的概率评分与拥有正确的预测同样重要。

完美校准与现实

一个完美校准的模型会在其预测概率和实际成功率之间显示出直接匹配：当它以90%的概率进行预测时，它应该在90%的情况下是正确的。这同样适用于所有概率水平。

然而，大多数模型并不是完美校准的。它们可能：

• 过于自信：给出的概率评分高于其实际性能
• 不够自信：给出的概率评分低于其实际性能
• 两者兼有：在某些范围内过于自信，而在其他范围内不够自信

预测概率与实际正确性之间的这种不匹配可能导致在实际应用中使用这些模型时做出糟糕的决策。这就是为什么理解和改善模型校准对于构建可靠的机器学习系统是必要的。

使用的数据集

为了探索模型校准，我们将继续使用我在之前关于分类算法的文章中使用的相同数据集：根据天气条件预测某人是否会去打高尔夫球。

import pandas as pd
import numpy as np
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
# Create and prepare dataset
dataset_dict = {
    'Outlook': ['sunny', 'sunny', 'overcast', 'rainy', 'rainy', 'rainy', 'overcast', 
                'sunny', 'sunny', 'rainy', 'sunny', 'overcast', 'overcast', 'rainy',
                'sunny', 'overcast', 'rainy', 'sunny', 'sunny', 'rainy', 'overcast',
                'rainy', 'sunny', 'overcast', 'sunny', 'overcast', 'rainy', 'overcast'],
    'Temperature': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0,
                   72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0,
                   88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
    'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0,
                 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0,
                 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
    'Wind': [False, True, False, False, False, True, True, False, False, False, True,
             True, False, True, True, False, False, True, False, True, True, False,
             True, False, False, True, False, False],
    'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes',
             'Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes',
             'Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
# Prepare data
df = pd.DataFrame(dataset_dict)

在训练模型之前，我们通过标准缩放对数值天气测量数据进行了归一化处理，并使用独热编码对分类特征进行了转换。这些预处理步骤确保了所有模型都能有效地使用数据，同时保证了模型之间的公平比较。

from sklearn.preprocessing import StandardScaler
df = pd.get_dummies(df, columns=['Outlook'], prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df['Play'] = (df['Play'] == 'Yes').astype(int)
# Rearrange columns
column_order = ['sunny', 'overcast', 'rainy', 'Temperature', 'Humidity', 'Wind', 'Play']
df = df[column_order]
# Prepare features and target
X,y = df.drop('Play', axis=1), df['Play']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
# Scale numerical features
scaler = StandardScaler()
X_train[['Temperature', 'Humidity']] = scaler.fit_transform(X_train[['Temperature', 'Humidity']])
X_test[['Temperature', 'Humidity']] = scaler.transform(X_test[['Temperature', 'Humidity']])

模型和训练

在本次探索中，我们训练了四个分类模型，并使其准确率得分相似：

• K-最近邻（kNN）
• 伯努利朴素贝叶斯
• 逻辑回归
• 多层感知机（MLP）

尽管在这个简单问题上这些模型的准确率相同，但它们计算预测概率的方式却不同。

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import BernoulliNB
# Initialize the models with the found parameters
knn = KNeighborsClassifier(n_neighbors=4, weights='distance')
bnb = BernoulliNB()
lr = LogisticRegression(C=1, random_state=42)
mlp = MLPClassifier(hidden_layer_sizes=(4, 2),random_state=42, max_iter=2000)
# Train all models
models = {
    'KNN': knn,
    'BNB': bnb,
    'LR': lr,
    'MLP': mlp
}
for name, model in models.items():
    model.fit(X_train, y_train)
# Create predictions and probabilities for each model
results_dict = {
    'True Labels': y_test
}
for name, model in models.items():
#    results_dict[f'{name} Pred'] = model.predict(X_test)
    results_dict[f'{name} Prob'] = model.predict_proba(X_test)[:, 1]
# Create results dataframe
results_df = pd.DataFrame(results_dict)
# Print predictions and probabilities
print("\nPredictions and Probabilities:")
print(results_df)
# Print accuracies
print("\nAccuracies:")
for name, model in models.items():
    accuracy = accuracy_score(y_test, model.predict(X_test))
    print(f"{name}: {accuracy:.3f}")

通过这些差异，我们将探讨为什么我们需要超越准确率来评估模型。

测量校准

为了评估模型的预测概率与其实际性能之间的匹配程度，我们使用了几种方法和指标。这些测量帮助我们了解模型的置信水平是否可靠。

Brier

Brier得分衡量的是预测概率与实际结果之间的均方差异。它的范围从0到1，得分越低表示校准越好。这个得分特别有用，因为它同时考虑了校准和准确率。

对数损失（Log Loss）

对数损失计算的是正确预测的负对数概率。这一指标对那些过于自信但错误的预测特别敏感——当模型表示它有90%的把握但却错误时，它会受到比表示有60%的把握但错误时大得多的惩罚。值越低表示校准越好。

预期校准误差（Expected Calibration Error, ECE）

ECE衡量的是预测概率与实际概率（取标签的平均值）之间的平均差异，根据每个概率组中包含的预测数量进行加权。这一指标有助于我们了解模型在其概率估计中是否存在系统性偏差。

可靠性图

与ECE类似，可靠性图（或校准曲线）通过将预测结果分组，并将其与实际结果进行比较，来可视化模型的校准情况。ECE给了我们一个衡量校准误差的单一数值，而可靠性图则以图形方式展示了相同的信息。我们使用相同的分组方法，并计算每个分组中实际正结果的频率。当绘制出来时，这些点可以准确地显示出模型的预测结果与完美校准之间的偏差，完美校准在图中会表现为一条对角线。

比较校准指标

这些指标中的每一个都展示了校准问题的不同方面：

• 高的布里尔得分表明概率估计总体较差。
• 高的对数损失指出模型对错误预测过于自信。
• 高的预期校准误差表明概率估计中存在系统性偏差。

这些指标共同为我们提供了模型概率得分反映其真实性能的完整画面。

我们的模型=

对于我们的模型，让我们计算校准指标并绘制它们的校准曲线：

from sklearn.metrics import brier_score_loss, log_loss
from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt
# Initialize models
models = {
    'k-Nearest Neighbors': KNeighborsClassifier(n_neighbors=4, weights='distance'),
    'Bernoulli Naive Bayes': BernoulliNB(),
    'Logistic Regression': LogisticRegression(C=1.5, random_state=42),
    'Multilayer Perceptron': MLPClassifier(hidden_layer_sizes=(4, 2), random_state=42, max_iter=2000)
}
# Get predictions and calculate metrics
metrics_dict = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_prob = model.predict_proba(X_test)[:, 1]
    metrics_dict[name] = {
        'Brier Score': brier_score_loss(y_test, y_prob),
        'Log Loss': log_loss(y_test, y_prob),
        'ECE': calculate_ece(y_test, y_prob),
        'Probabilities': y_prob
    }
# Plot calibration curves
fig, axes = plt.subplots(2, 2, figsize=(8, 8), dpi=300)
colors = ['orangered', 'slategrey', 'gold', 'mediumorchid']
for idx, (name, metrics) in enumerate(metrics_dict.items()):
    ax = axes.ravel()[idx]
    prob_true, prob_pred = calibration_curve(y_test, metrics['Probabilities'], 
                                           n_bins=5, strategy='uniform')
    
    ax.plot([0, 1], [0, 1], 'k--', label='Perfectly calibrated')
    ax.plot(prob_pred, prob_true, color=colors[idx], marker='o', 
            label='Calibration curve', linewidth=2, markersize=8)
    
    title = f'{name}\nBrier: {metrics["Brier Score"]:.3f} | Log Loss: {metrics["Log Loss"]:.3f} | ECE: {metrics["ECE"]:.3f}'
    ax.set_title(title, fontsize=11, pad=10)
    ax.grid(True, alpha=0.7)
    ax.set_xlim([-0.05, 1.05])
    ax.set_ylim([-0.05, 1.05])
    ax.spines[['top', 'right', 'left', 'bottom']].set_visible(False)
    ax.legend(fontsize=10, loc='upper left')
plt.tight_layout()
plt.show()

现在，让我们基于这些指标分析每个模型的校准性能：

K-最近邻（KNN）模型在估计其预测应有的确定性方面表现良好。其图形线条紧贴虚线，表明性能良好。它的得分很稳健——布里尔得分为0.148，预期校准误差得分为0.090，是最佳得分。虽然它在中间范围内有时会表现出过度自信，但总体上对其确定性的估计是可靠的。

伯努利朴素贝叶斯模型的线条呈现出一种不寻常的阶梯状模式。这意味着它在不同的确定性水平之间跳跃，而不是平滑地变化。虽然它的布里尔得分与KNN相同（0.148），但其较高的预期校准误差（0.150）表明它在估计其确定性时准确性较低。该模型在过度自信和不够自信之间切换。

逻辑回归模型的预测存在明显问题。其线条远离虚线，这意味着它经常误判其应有的确定性。它的预期校准误差得分最差（0.181），布里尔得分也较差（0.164）。该模型一致地对其预测表现出过度自信，使其不可靠。

多层感知机显示出一个明显的问题。尽管其布里尔得分最佳（0.129），但其线条显示，它大多做出极端预测——要么非常确定，要么非常不确定，中间几乎没有过渡。其较高的预期校准误差（0.167）以及中间范围内的平坦线条表明，它在做出均衡的确定性估计方面存在困难。

在检查了所有四个模型后，k-最近邻模型在估计其预测确定性方面表现明显最佳。它在不同确定性水平上保持了一致的性能，并在其预测中显示出最可靠的模式。虽然其他模型在某些指标上可能得分不错（如多层感知机的布里尔得分），但它们的图形显示，在需要我们信任其确定性估计时，它们并不那么可靠。

结论

在不同模型之间进行选择时，我们需要同时考虑它们的准确性和校准质量。一个准确性略低但校准更好的模型，可能比一个准确性很高但概率估计很差的模型更有价值。

通过理解校准及其重要性，我们可以构建更可靠的机器学习系统，用户不仅可以信任其预测，还可以信任其对这些预测的信心。

模型校准代码总结（1个模型）

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.metrics import brier_score_loss, log_loss
from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt
# Define ECE
def calculate_ece(y_true, y_prob, n_bins=5):
    bins = np.linspace(0, 1, n_bins + 1)
    ece = 0
    for bin_lower, bin_upper in zip(bins[:-1], bins[1:]):
        mask = (y_prob >= bin_lower) & (y_prob < bin_upper)
        if np.sum(mask) > 0:
            bin_conf = np.mean(y_prob[mask])
            bin_acc = np.mean(y_true[mask])
            ece += np.abs(bin_conf - bin_acc) * np.sum(mask)
    return ece / len(y_true)
# Create dataset and prepare data
dataset_dict = {
    'Outlook': ['sunny', 'sunny', 'overcast', 'rainy', 'rainy', 'rainy', 'overcast','sunny', 'sunny', 'rainy', 'sunny', 'overcast', 'overcast', 'rainy','sunny', 'overcast', 'rainy', 'sunny', 'sunny', 'rainy', 'overcast','rainy', 'sunny', 'overcast', 'sunny', 'overcast', 'rainy', 'overcast'],
    'Temperature': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0,72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0,88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
    'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0,90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0,65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
    'Wind': [False, True, False, False, False, True, True, False, False, False, True,True, False, True, True, False, False, True, False, True, True, False,True, False, False, True, False, False],
    'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes','Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes','Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
# Prepare and encode data
df = pd.DataFrame(dataset_dict)
df = pd.get_dummies(df, columns=['Outlook'], prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df['Play'] = (df['Play'] == 'Yes').astype(int)
df = df[['sunny', 'overcast', 'rainy', 'Temperature', 'Humidity', 'Wind', 'Play']]
# Split and scale data
X, y = df.drop('Play', axis=1), df['Play']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
scaler = StandardScaler()
X_train[['Temperature', 'Humidity']] = scaler.fit_transform(X_train[['Temperature', 'Humidity']])
X_test[['Temperature', 'Humidity']] = scaler.transform(X_test[['Temperature', 'Humidity']])
# Train model and get predictions
model = BernoulliNB()
model.fit(X_train, y_train)
y_prob = model.predict_proba(X_test)[:, 1]
# Calculate metrics
metrics = {
    'Brier Score': brier_score_loss(y_test, y_prob),
    'Log Loss': log_loss(y_test, y_prob),
    'ECE': calculate_ece(y_test, y_prob)
}
# Plot calibration curve
plt.figure(figsize=(6, 6), dpi=300)
prob_true, prob_pred = calibration_curve(y_test, y_prob, n_bins=5, strategy='uniform')
plt.plot([0, 1], [0, 1], 'k--', label='Perfectly calibrated')
plt.plot(prob_pred, prob_true, color='slategrey', marker='o', 
        label='Calibration curve', linewidth=2, markersize=8)
title = f'Bernoulli Naive Bayes\nBrier: {metrics["Brier Score"]:.3f} | Log Loss: {metrics["Log Loss"]:.3f} | ECE: {metrics["ECE"]:.3f}'
plt.title(title, fontsize=11, pad=10)
plt.grid(True, alpha=0.7)
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plt.gca().spines[['top', 'right', 'left', 'bottom']].set_visible(False)
plt.legend(fontsize=10, loc='lower right')
plt.tight_layout()
plt.show()

模型校准代码总结（4个模型）

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import BernoulliNB
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import brier_score_loss, log_loss
from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt
# Define ECE
def calculate_ece(y_true, y_prob, n_bins=5):
    bins = np.linspace(0, 1, n_bins + 1)
    ece = 0
    for bin_lower, bin_upper in zip(bins[:-1], bins[1:]):
        mask = (y_prob >= bin_lower) & (y_prob < bin_upper)
        if np.sum(mask) > 0:
            bin_conf = np.mean(y_prob[mask])
            bin_acc = np.mean(y_true[mask])
            ece += np.abs(bin_conf - bin_acc) * np.sum(mask)
    return ece / len(y_true)
# Create dataset and prepare data
dataset_dict = {
    'Outlook': ['sunny', 'sunny', 'overcast', 'rainy', 'rainy', 'rainy', 'overcast','sunny', 'sunny', 'rainy', 'sunny', 'overcast', 'overcast', 'rainy','sunny', 'overcast', 'rainy', 'sunny', 'sunny', 'rainy', 'overcast','rainy', 'sunny', 'overcast', 'sunny', 'overcast', 'rainy', 'overcast'],
    'Temperature': [85.0, 80.0, 83.0, 70.0, 68.0, 65.0, 64.0, 72.0, 69.0, 75.0, 75.0,72.0, 81.0, 71.0, 81.0, 74.0, 76.0, 78.0, 82.0, 67.0, 85.0, 73.0,88.0, 77.0, 79.0, 80.0, 66.0, 84.0],
    'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0,90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0,65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
    'Wind': [False, True, False, False, False, True, True, False, False, False, True,True, False, True, True, False, False, True, False, True, True, False,True, False, False, True, False, False],
    'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes','Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes','Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
# Prepare and encode data
df = pd.DataFrame(dataset_dict)
df = pd.get_dummies(df, columns=['Outlook'], prefix='', prefix_sep='', dtype=int)
df['Wind'] = df['Wind'].astype(int)
df['Play'] = (df['Play'] == 'Yes').astype(int)
df = df[['sunny', 'overcast', 'rainy', 'Temperature', 'Humidity', 'Wind', 'Play']]
# Split and scale data
X, y = df.drop('Play', axis=1), df['Play']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
scaler = StandardScaler()
X_train[['Temperature', 'Humidity']] = scaler.fit_transform(X_train[['Temperature', 'Humidity']])
X_test[['Temperature', 'Humidity']] = scaler.transform(X_test[['Temperature', 'Humidity']])
# Initialize models
models = {
    'k-Nearest Neighbors': KNeighborsClassifier(n_neighbors=4, weights='distance'),
    'Bernoulli Naive Bayes': BernoulliNB(),
    'Logistic Regression': LogisticRegression(C=1.5, random_state=42),
    'Multilayer Perceptron': MLPClassifier(hidden_layer_sizes=(4, 2), random_state=42, max_iter=2000)
}
# Get predictions and calculate metrics
metrics_dict = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_prob = model.predict_proba(X_test)[:, 1]
    metrics_dict[name] = {
        'Brier Score': brier_score_loss(y_test, y_prob),
        'Log Loss': log_loss(y_test, y_prob),
        'ECE': calculate_ece(y_test, y_prob),
        'Probabilities': y_prob
    }
# Plot calibration curves
fig, axes = plt.subplots(2, 2, figsize=(8, 8), dpi=300)
colors = ['orangered', 'slategrey', 'gold', 'mediumorchid']
for idx, (name, metrics) in enumerate(metrics_dict.items()):
    ax = axes.ravel()[idx]
    prob_true, prob_pred = calibration_curve(y_test, metrics['Probabilities'], 
                                           n_bins=5, strategy='uniform')
    
    ax.plot([0, 1], [0, 1], 'k--', label='Perfectly calibrated')
    ax.plot(prob_pred, prob_true, color=colors[idx], marker='o', 
            label='Calibration curve', linewidth=2, markersize=8)
    
    title = f'{name}\nBrier: {metrics["Brier Score"]:.3f} | Log Loss: {metrics["Log Loss"]:.3f} | ECE: {metrics["ECE"]:.3f}'
    ax.set_title(title, fontsize=11, pad=10)
    ax.grid(True, alpha=0.7)
    ax.set_xlim([-0.05, 1.05])
    ax.set_ylim([-0.05, 1.05])
    ax.spines[['top', 'right', 'left', 'bottom']].set_visible(False)
    ax.legend(fontsize=10, loc='upper left')
plt.tight_layout()
plt.show()