Clasificación binaria de flores Iris utilizando SVM

Introducción

Este tutorial explicará el proceso de uso de diferentes kernels de SVM para la clasificación. Utilizaremos el conjunto de datos Iris, que contiene mediciones de flores. Este conjunto de datos tiene tres clases, pero solo utilizaremos dos de ellas para la clasificación binaria.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y resolveremos el problema rápidamente para usted.

Skills Graph

Cargar los datos

Comenzaremos cargando el conjunto de datos Iris y seleccionando solo las primeras dos características con fines de visualización.

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

iris = datasets.load_iris()
X = iris.data
y = iris.target

X = X[y!= 0, :2]
y = y[y!= 0]

Preparar los datos

A continuación, prepararemos los datos para el entrenamiento y la prueba. Dividiremos los datos en un 90% para el entrenamiento y un 10% para la prueba.

n_sample = len(X)

np.random.seed(0)
order = np.random.permutation(n_sample)
X = X[order]
y = y[order].astype(float)

X_train = X[: int(0.9 * n_sample)]
y_train = y[: int(0.9 * n_sample)]
X_test = X[int(0.9 * n_sample) :]
y_test = y[int(0.9 * n_sample) :]

Entrenar el modelo con diferentes kernels

Ahora entrenaremos el modelo SVM utilizando tres kernels diferentes: lineal, rbf y polinomial. Para cada kernel, ajustaremos el modelo a los datos de entrenamiento, graficaremos el límite de decisión y mostraremos la precisión en los datos de prueba.

## ajustar el modelo
for kernel in ("linear", "rbf", "poly"):
    clf = svm.SVC(kernel=kernel, gamma=10)
    clf.fit(X_train, y_train)

    plt.figure()
    plt.clf()
    plt.scatter(
        X[:, 0], X[:, 1], c=y, zorder=10, cmap=plt.cm.Paired, edgecolor="k", s=20
    )

    ## Resaltar los datos de prueba
    plt.scatter(
        X_test[:, 0], X_test[:, 1], s=80, facecolors="none", zorder=10, edgecolor="k"
    )

    plt.axis("tight")
    x_min = X[:, 0].min()
    x_max = X[:, 0].max()
    y_min = X[:, 1].min()
    y_max = X[:, 1].max()

    XX, YY = np.mgrid[x_min:x_max:200j, y_min:y_max:200j]
    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])

    ## Colocar el resultado en un gráfico de color
    Z = Z.reshape(XX.shape)
    plt.pcolormesh(XX, YY, Z > 0, cmap=plt.cm.Paired)
    plt.contour(
        XX,
        YY,
        Z,
        colors=["k", "k", "k"],
        linestyles=["--", "-", "--"],
        levels=[-0.5, 0, 0.5],
    )

    plt.title(kernel)
    plt.show()

    print(f"Precisión con el kernel {kernel}: {clf.score(X_test, y_test)}")

Interpretar los resultados

Podemos ver que el kernel lineal produce un límite de decisión lineal, mientras que los kernels rbf y polinomial producen límites más complejos. La precisión en los datos de prueba es la más alta con el kernel rbf, seguida del kernel polinomial y luego del kernel lineal.

Resumen

En este tutorial, aprendimos cómo utilizar diferentes kernels de SVM para la clasificación. Entrenamos un modelo SVM con tres kernels diferentes y visualizamos los límites de decisión para cada uno. También calculamos la precisión en los datos de prueba para cada kernel. Encontramos que el kernel rbf produjo los mejores resultados para el conjunto de datos Iris.