Classificação Binária de Flores Iris Usando SVM

Introdução

Este tutorial irá percorrer o processo de utilização de diferentes núcleos SVM para classificação. Usaremos o conjunto de dados Iris, que contém medições de flores. Este conjunto de dados possui três classes, mas usaremos apenas duas delas para classificação binária.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para praticar.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Carregar os Dados

Começaremos carregando o conjunto de dados Iris e selecionando apenas as duas primeiras características para fins de visualização.

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 os Dados

Em seguida, prepararemos os dados para treino e teste. Dividiremos os dados em 90% para treino e 10% para teste.

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) :]

Treinar o Modelo com Núcleos Diferentes

Agora, treinaremos o modelo SVM usando três núcleos diferentes: linear, rbf e polinomial. Para cada núcleo, ajustaremos o modelo aos dados de treino, plotaremos a fronteira de decisão e mostraremos a precisão nos dados de teste.

## ajustar o 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
    )

    ## Destacar os dados de teste
    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 o resultado em um gráfico de cores
    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"Precisão com o núcleo {kernel}: {clf.score(X_test, y_test)}")

Interpretar os Resultados

Podemos observar que o núcleo linear produz uma fronteira de decisão linear, enquanto os núcleos rbf e polinomial produzem fronteiras mais complexas. A precisão nos dados de teste é mais alta com o núcleo rbf, seguido pelo núcleo polinomial e, em seguida, pelo núcleo linear.

Resumo

Neste tutorial, aprendemos como usar diferentes núcleos SVM para classificação. Treinamos um modelo SVM com três núcleos diferentes e visualizamos as fronteiras de decisão para cada um. Também calculamos a precisão nos dados de teste para cada núcleo. Descobrimos que o núcleo rbf produziu os melhores resultados para o conjunto de dados Iris.