Classificadores Semi-Supervisionados no Conjunto de Dados Iris

Introdução

Neste laboratório, exploraremos classificadores semi-supervisionados no conjunto de dados Iris. Compararemos os limites de decisão gerados por Label Spreading, Self-training e Support Vector Machine (SVM) no conjunto de dados Iris. Usaremos o scikit-learn, uma popular biblioteca de aprendizado de máquina Python, para implementar os classificadores e visualizar os limites de decisão.

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 a prática.

Às 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 o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar o conjunto de dados Iris e dividir os dados

Vamos carregar o conjunto de dados Iris, um conjunto de dados amplamente utilizado em aprendizado de máquina para tarefas de classificação. O conjunto de dados contém 150 amostras de flores Iris, com quatro características para cada amostra: comprimento da sépala, largura da sépala, comprimento da pétala e largura da pétala. Vamos dividir o conjunto de dados em características de entrada e rótulos de destino.

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

## Carregar o conjunto de dados Iris
iris = datasets.load_iris()

## Dividir o conjunto de dados em características de entrada e rótulos de destino
X = iris.data[:, :2] ## Usaremos apenas as duas primeiras características para fins de visualização
y = iris.target

Configurar os classificadores Label Spreading

Vamos configurar três classificadores Label Spreading com diferentes percentagens de dados rotulados: 30%, 50% e 100%. Label Spreading é um algoritmo de aprendizagem semi-supervisionada que propaga rótulos de pontos de dados rotulados para pontos de dados não rotulados com base na semelhança entre eles.

from sklearn.semi_supervised import LabelSpreading

## Configurar os classificadores Label Spreading
rng = np.random.RandomState(0)
y_rand = rng.rand(y.shape[0])
y_30 = np.copy(y)
y_30[y_rand < 0.3] = -1  ## definir amostras aleatórias como não rotuladas
y_50 = np.copy(y)
y_50[y_rand < 0.5] = -1
ls30 = (LabelSpreading().fit(X, y_30), y_30, "Label Spreading 30% de dados")
ls50 = (LabelSpreading().fit(X, y_50), y_50, "Label Spreading 50% de dados")
ls100 = (LabelSpreading().fit(X, y), y, "Label Spreading 100% de dados")

Configurar os classificadores Self-training

Vamos configurar dois classificadores Self-training com diferentes percentagens de dados rotulados: 30% e 50%. Self-training é um algoritmo de aprendizagem semi-supervisionada que treina um classificador nos dados rotulados e, em seguida, o utiliza para prever os rótulos dos dados não rotulados. As previsões mais confiáveis são adicionadas aos dados rotulados e o processo é repetido até a convergência.

from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.svm import SVC

## Configurar os classificadores Self-training
base_classifier = SVC(kernel="rbf", gamma=0.5, probability=True)
st30 = (
    SelfTrainingClassifier(base_classifier).fit(X, y_30),
    y_30,
    "Self-training 30% de dados",
)
st50 = (
    SelfTrainingClassifier(base_classifier).fit(X, y_50),
    y_50,
    "Self-training 50% de dados",
)

Configurar o classificador SVM

Vamos configurar um classificador SVM com um kernel de função de base radial (RBF). SVM é um algoritmo de aprendizagem supervisionada que encontra o hiperplano ótimo que separa os dados em diferentes classes.

from sklearn.svm import SVC

## Configurar o classificador SVM
rbf_svc = (SVC(kernel="rbf", gamma=0.5).fit(X, y), y, "SVC com kernel rbf")

Visualizar as fronteiras de decisão

Criaremos uma malha de pontos que cobre o espaço de características de entrada e usaremos cada classificador para prever as etiquetas dos pontos na malha. Em seguida, plotaremos as fronteiras de decisão e os pontos de dados rotulados.

## Criar uma malha para plotar
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

## Definir uma tabela de cores para as etiquetas
color_map = {-1: (1, 1, 1), 0: (0, 0, 0.9), 1: (1, 0, 0), 2: (0.8, 0.6, 0)}

## Configurar os classificadores
classifiers = (ls30, st30, ls50, st50, ls100, rbf_svc)

## Plotar as fronteiras de decisão e os pontos de dados rotulados para cada classificador
for i, (clf, y_train, title) in enumerate(classifiers):
    ## Plotar a fronteira de decisão
    plt.subplot(3, 2, i + 1)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

    ## Colocar o resultado num gráfico de cores
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
    plt.axis("off")

    ## Plotar os pontos de dados rotulados
    colors = [color_map[y] for y in y_train]
    plt.scatter(X[:, 0], X[:, 1], c=colors, edgecolors="black")

    plt.title(title)

plt.suptitle("Os pontos não rotulados são coloridos de branco", y=0.1)
plt.show()

Resumo

Neste laboratório, explorámos classificadores semi-supervisionados no conjunto de dados Iris. Comparámos as fronteiras de decisão geradas pelo Label Spreading, Self-training e SVM no conjunto de dados Iris. Utilizámos o scikit-learn para implementar os classificadores e visualizar as fronteiras de decisão. Concluímos que o Label Spreading e o Self-training podem aprender boas fronteiras de decisão mesmo quando pequenas quantidades de dados rotulados estão disponíveis.