Vergleich verschiedener linearer SVM-Klassifikatoren auf einer 2D-Projektion des Iris-Datensatzes. Wir betrachten nur die ersten 2 Merkmale dieses Datensatzes:

  • Kelchlänge
  • Kelchbreite

Dieses Beispiel zeigt, wie die Entscheidungsoberfläche für vier SVM-Klassifikatoren mit unterschiedlichen Kerneln gezeichnet wird.

Die linearen Modelle LinearSVC() und SVC(kernel="linear") ergeben leicht unterschiedliche Entscheidungsgrenzen. Dies kann eine Folge der folgenden Unterschiede sein:

  • LinearSVC minimiert den quadratischen Scharnierverlust, während SVC minimiert den regelmäßigen Scharnierverlust.
  • LinearSVC verwendet die Mehrklassenreduktion One-vs-All (auch bekannt als One-vs-Rest), während SVC verwendet die Ein-gegen-Eins-Mehrklassenreduktion.

Beide linearen Modelle haben lineare Entscheidungsgrenzen (sich schneidende Hyperebenen), während die nichtlinearen Kernelmodelle (polynomial oder Gaussian RBF) flexiblere nichtlineare Entscheidungsgrenzen mit Formen haben, die von der Art des Kernels und seinen Parametern abhängen.

Notiz

Während das Plotten der Entscheidungsfunktion von Klassifikatoren für Spielzeug-2D-Datensätze zu einem intuitiven Verständnis ihrer jeweiligen Ausdruckskraft beitragen kann, sollten Sie sich bewusst sein, dass diese Intuitionen nicht immer auf realistischere hochdimensionale Probleme verallgemeinern.

SVC mit linearem Kernel, LinearSVC (linearer Kernel), SVC mit RBF-Kernel, SVC mit polynomialem (Grad 3) Kernel

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets


def make_meshgrid(x, y, h=.02):
    """Create a mesh of points to plot in

    Parameters
    ----------
    x: data to base x-axis meshgrid on
    y: data to base y-axis meshgrid on
    h: stepsize for meshgrid, optional

    Returns
    -------
    xx, yy : ndarray
    """
    x_min, x_max = x.min() - 1, x.max() + 1
    y_min, y_max = y.min() - 1, y.max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    return xx, yy


def plot_contours(ax, clf, xx, yy, **params):
    """Plot the decision boundaries for a classifier.

    Parameters
    ----------
    ax: matplotlib axes object
    clf: a classifier
    xx: meshgrid ndarray
    yy: meshgrid ndarray
    params: dictionary of params to pass to contourf, optional
    """
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    out = ax.contourf(xx, yy, Z, **params)
    return out


# import some data to play with
iris = datasets.load_iris()
# Take the first two features. We could avoid this by using a two-dim dataset
X = iris.data[:, :2]
y = iris.target

# we create an instance of SVM and fit out data. We do not scale our
# data since we want to plot the support vectors
C = 1.0  # SVM regularization parameter
models = (svm.SVC(kernel='linear', C=C),
          svm.LinearSVC(C=C, max_iter=10000),
          svm.SVC(kernel='rbf', gamma=0.7, C=C),
          svm.SVC(kernel='poly', degree=3, gamma='auto', C=C))
models = (clf.fit(X, y) for clf in models)

# title for the plots
titles = ('SVC with linear kernel',
          'LinearSVC (linear kernel)',
          'SVC with RBF kernel',
          'SVC with polynomial (degree 3) kernel')

# Set-up 2x2 grid for plotting.
fig, sub = plt.subplots(2, 2)
plt.subplots_adjust(wspace=0.4, hspace=0.4)

X0, X1 = X[:, 0], X[:, 1]
xx, yy = make_meshgrid(X0, X1)

for clf, title, ax in zip(models, titles, sub.flatten()):
    plot_contours(ax, clf, xx, yy,
                  cmap=plt.cm.coolwarm, alpha=0.8)
    ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors='k')
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xlabel('Sepal length')
    ax.set_ylabel('Sepal width')
    ax.set_xticks(())
    ax.set_yticks(())
    ax.set_title(title)

plt.show()

Gesamtlaufzeit des Skripts: (0 Minuten 1,364 Sekunden)

Startordner

Download Python source code: plot_iris_svc.py

Download Jupyter notebook: plot_iris_svc.ipynb