Визуализация вероятностных предсказаний VotingClassifier

Построение графика предсказанных вероятностей классов на игрушечном наборе данных: их предсказывают три разных классификатора, а затем усредняет VotingClassifier.

Сначала инициализируются три линейных классификатора. Два из них — сплайновые модели с членами взаимодействия: одна использует постоянную экстраполяцию, другая — периодическую. Третий классификатор — это Nystroem с ядром «rbf» по умолчанию.

В первой части примера эти три классификатора используются для демонстрации мягкого голосования с помощью VotingClassifier с взвешенным средним. Задаём weights=[2, 1, 3]: предсказания сплайновой модели с постоянной экстраполяцией получают вдвое больший вес, чем предсказания модели с периодической экстраполяцией, а предсказания модели Nystroem — втрое больший вес, чем предсказания периодического сплайна.

Во второй части показано, как мягкие предсказания можно преобразовать в жёсткие.

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

Сначала мы создаём зашумлённый набор данных XOR, предназначенный для задачи бинарной классификации.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.colors import ListedColormap

n_samples = 500
rng = np.random.default_rng(0)
feature_names = ["Feature #0", "Feature #1"]
common_scatter_plot_params = dict(
    cmap=ListedColormap(["tab:red", "tab:blue"]),
    edgecolor="white",
    linewidth=1,
)

xor = pd.DataFrame(
    np.random.RandomState(0).uniform(low=-1, high=1, size=(n_samples, 2)),
    columns=feature_names,
)
noise = rng.normal(loc=0, scale=0.1, size=(n_samples, 2))
target_xor = np.logical_xor(
    xor["Feature #0"] + noise[:, 0] > 0, xor["Feature #1"] + noise[:, 1] > 0
)

X = xor[feature_names]
y = target_xor.astype(np.int32)

fig, ax = plt.subplots()
ax.scatter(X["Feature #0"], X["Feature #1"], c=y, **common_scatter_plot_params)
ax.set_title("The XOR dataset")
plt.show()

Из-за присущей набору данных XOR нелинейной разделимости часто предпочтение отдаётся моделям на основе деревьев. Однако правильно подобранная инженерия признаков в сочетании с линейной моделью может дать эффективные результаты, а также обеспечить лучше откалиброванные вероятности для образцов, расположенных в переходных областях, на которые влияет шум.

Определим модели и обучим их на всём наборе данных.

from sklearn.ensemble import VotingClassifier
from sklearn.kernel_approximation import Nystroem
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, SplineTransformer, StandardScaler

clf1 = make_pipeline(
    SplineTransformer(degree=2, n_knots=2),
    PolynomialFeatures(interaction_only=True),
    LogisticRegression(C=10),
)
clf2 = make_pipeline(
    SplineTransformer(
        degree=2,
        n_knots=4,
        extrapolation="periodic",
        include_bias=True,
    ),
    PolynomialFeatures(interaction_only=True),
    LogisticRegression(C=10),
)
clf3 = make_pipeline(
    StandardScaler(),
    Nystroem(gamma=2, random_state=0),
    LogisticRegression(C=10),
)
weights = [2, 1, 3]
eclf = VotingClassifier(
    estimators=[
        ("constant splines model", clf1),
        ("periodic splines model", clf2),
        ("nystroem model", clf3),
    ],
    voting="soft",
    weights=weights,
)

clf1.fit(X, y)
clf2.fit(X, y)
clf3.fit(X, y)
eclf.fit(X, y)

VotingClassifier(estimators=[('constant splines model',
                              Pipeline(steps=[('splinetransformer',
                                               SplineTransformer(degree=2,
                                                                 n_knots=2)),
                                              ('polynomialfeatures',
                                               PolynomialFeatures(interaction_only=True)),
                                              ('logisticregression',
                                               LogisticRegression(C=10))])),
                             ('periodic splines model',
                              Pipeline(steps=[('splinetransformer',
                                               SplineTransformer(degree=2,
                                                                 extrapolation='periodic',
                                                                 n_knots=4)),
                                              ('polynomialfeatures',
                                               PolynomialFeatures(interaction_only=True)),
                                              ('logisticregression',
                                               LogisticRegression(C=10))])),
                             ('nystroem model',
                              Pipeline(steps=[('standardscaler',
                                               StandardScaler()),
                                              ('nystroem',
                                               Nystroem(gamma=2,
                                                        random_state=0)),
                                              ('logisticregression',
                                               LogisticRegression(C=10))]))],
                 voting='soft', weights=[2, 1, 3])

Наконец, используем DecisionBoundaryDisplay, чтобы построить график предсказанных вероятностей. Используя расходящуюся цветовую карту (например, "RdBu"), мы можем убедиться, что более темные цвета соответствуют predict_proba, близким к 0 или 1, а белый цвет — predict_proba, равным 0.5.

from itertools import product

from sklearn.inspection import DecisionBoundaryDisplay

fig, axarr = plt.subplots(2, 2, sharex="col", sharey="row", figsize=(10, 8))
for idx, clf, title in zip(
    product([0, 1], [0, 1]),
    [clf1, clf2, clf3, eclf],
    [
        "Splines with\nconstant extrapolation",
        "Splines with\nperiodic extrapolation",
        "RBF Nystroem",
        "Soft Voting",
    ],
):
    disp = DecisionBoundaryDisplay.from_estimator(
        clf,
        X,
        response_method="predict_proba",
        plot_method="pcolormesh",
        cmap="RdBu",
        alpha=0.8,
        ax=axarr[idx[0], idx[1]],
    )
    axarr[idx[0], idx[1]].scatter(
        X["Feature #0"],
        X["Feature #1"],
        c=y,
        **common_scatter_plot_params,
    )
    axarr[idx[0], idx[1]].set_title(title)
    fig.colorbar(disp.surface_, ax=axarr[idx[0], idx[1]], label="Probability estimate")

plt.show()

Для проверки можно убедиться, что для заданного образца вероятность, предсказанная VotingClassifier, действительно является взвешенным средним мягких предсказаний отдельных классификаторов.

В случае бинарной классификации, как в данном примере, массивы predict_proba содержат вероятность принадлежности к классу 0 (здесь обозначена красным) в качестве первого элемента и вероятность принадлежности к классу 1 (здесь обозначена синим) в качестве второго элемента.

test_sample = pd.DataFrame({"Feature #0": [-0.5], "Feature #1": [1.5]})
predict_probas = [est.predict_proba(test_sample).ravel() for est in eclf.estimators_]
for (est_name, _), est_probas in zip(eclf.estimators, predict_probas):
    print(f"{est_name}'s predicted probabilities: {est_probas}")

constant splines model's predicted probabilities: [0.11272662 0.88727338]
periodic splines model's predicted probabilities: [0.99726573 0.00273427]
nystroem model's predicted probabilities: [0.3185838 0.6814162]

print(
    "Weighted average of soft-predictions: "
    f"{np.dot(weights, predict_probas) / np.sum(weights)}"
)

Weighted average of soft-predictions: [0.3630784 0.6369216]

Как видно, приведенный выше ручной расчет предсказанных вероятностей эквивалентен результату VotingClassifier:

print(
    "Predicted probability of VotingClassifier: "
    f"{eclf.predict_proba(test_sample).ravel()}"
)

Predicted probability of VotingClassifier: [0.3630784 0.6369216]

Чтобы преобразовать мягкие предсказания в жесткие при наличии весов, для каждого класса вычисляется взвешенное среднее предсказанных вероятностей. Затем итоговая метка класса определяется по метке класса с наибольшей средней вероятностью, что соответствует порогу по умолчанию predict_proba=0.5 в случае бинарной классификации.

print(
    "Class with the highest weighted average of soft-predictions: "
    f"{np.argmax(np.dot(weights, predict_probas) / np.sum(weights))}"
)

Class with the highest weighted average of soft-predictions: 1

Это эквивалентно результату метода predict объекта VotingClassifier:

print(f"Predicted class of VotingClassifier: {eclf.predict(test_sample).ravel()}")

Predicted class of VotingClassifier: [1]

Мягкие голоса можно порогово преобразовывать, как и результаты любого другого вероятностного классификатора. Это позволяет задать порог вероятности, при превышении которого будет предсказываться положительный класс, вместо того чтобы просто выбирать класс с наибольшей предсказанной вероятностью.

from sklearn.model_selection import FixedThresholdClassifier

eclf_other_threshold = FixedThresholdClassifier(
    eclf, threshold=0.7, response_method="predict_proba"
).fit(X, y)
print(
    "Predicted class of thresholded VotingClassifier: "
    f"{eclf_other_threshold.predict(test_sample)}"
)

Predicted class of thresholded VotingClassifier: [0]

Общее время выполнения скрипта: (0 минут 0.713 секунды)

Download Jupyter notebook: plot_voting_decision_regions.ipynb

Download Python source code: plot_voting_decision_regions.py

Download zipped: plot_voting_decision_regions.zip

Связанные примеры

График вероятности классификации

Полиномиальная и сплайновая интерполяция

Сравнение калибровки классификаторов

Примеры использования FrozenEstimator