Classifieurs semi-supervisés sur l'ensemble de données Iris

Introduction

Dans ce laboratoire, nous explorerons les classifieurs semi-supervisés sur l'ensemble de données Iris. Nous comparerons les limites de décision générées par Label Spreading, Self-training et Support Vector Machine (SVM) sur l'ensemble de données Iris. Nous utiliserons scikit-learn, une bibliothèque populaire de machine learning en Python, pour implémenter les classifieurs et visualiser les limites de décision.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Charger l'ensemble de données Iris et diviser les données

Nous allons charger l'ensemble de données Iris, qui est un ensemble de données largement utilisé en machine learning pour les tâches de classification. L'ensemble de données contient 150 échantillons de fleurs Iris, avec quatre caractéristiques pour chaque échantillon : longueur du sépale, largeur du sépale, longueur des pétales et largeur des pétales. Nous allons diviser l'ensemble de données en caractéristiques d'entrée et en étiquettes cibles.

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

## Charger l'ensemble de données Iris
iris = datasets.load_iris()

## Diviser l'ensemble de données en caractéristiques d'entrée et en étiquettes cibles
X = iris.data[:, :2] ## Nous n'utiliserons que les deux premières caractéristiques à des fins de visualisation
y = iris.target

Configurer les classifieurs Label Spreading

Nous allons configurer trois classifieurs Label Spreading avec différents pourcentages de données étiquetées : 30 %, 50 % et 100 %. Label Spreading est un algorithme d'apprentissage semi-supervisé qui propage les étiquettes des points de données étiquetés vers les points de données non étiquetés sur la base de leur similarité.

from sklearn.semi_supervised import LabelSpreading

## Configurer les classifieurs 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  ## définir des échantillons aléatoires comme non étiquetés
y_50 = np.copy(y)
y_50[y_rand < 0.5] = -1
ls30 = (LabelSpreading().fit(X, y_30), y_30, "Label Spreading 30% des données")
ls50 = (LabelSpreading().fit(X, y_50), y_50, "Label Spreading 50% des données")
ls100 = (LabelSpreading().fit(X, y), y, "Label Spreading 100% des données")

Configurer les classifieurs Self-training

Nous allons configurer deux classifieurs Self-training avec différents pourcentages de données étiquetées : 30 % et 50 %. Self-training est un algorithme d'apprentissage semi-supervisé qui entraîne un classifieur sur les données étiquetées puis l'utilise pour prédire les étiquettes des données non étiquetées. Les prédictions les plus sûres sont ajoutées aux données étiquetées et le processus est répété jusqu'à convergence.

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

## Configurer les classifieurs 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% des données",
)
st50 = (
    SelfTrainingClassifier(base_classifier).fit(X, y_50),
    y_50,
    "Self-training 50% des données",
)

Configurer le classifieur SVM

Nous allons configurer un classifieur SVM avec un noyau de fonction de base radiale (RBF). Le SVM est un algorithme d'apprentissage supervisé qui trouve l'hyperplan optimal qui sépare les données en différentes classes.

from sklearn.svm import SVC

## Configurer le classifieur SVM
rbf_svc = (SVC(kernel="rbf", gamma=0.5).fit(X, y), y, "SVC avec noyau rbf")

Visualiser les limites de décision

Nous allons créer une grille de points qui couvre l'espace de caractéristiques d'entrée et utiliser chaque classifieur pour prédire les étiquettes des points dans la grille de points. Nous allons ensuite tracer les limites de décision et les points de données étiquetés.

## Create a mesh grid to plot in
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))

## Define a color map for the labels
color_map = {-1: (1, 1, 1), 0: (0, 0, 0.9), 1: (1, 0, 0), 2: (0.8, 0.6, 0)}

## Set up the classifiers
classifiers = (ls30, st30, ls50, st50, ls100, rbf_svc)

## Plot the decision boundaries and labeled data points for each classifier
for i, (clf, y_train, title) in enumerate(classifiers):
    ## Plot the decision boundary
    plt.subplot(3, 2, i + 1)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

    ## Put the result into a color plot
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
    plt.axis("off")

    ## Plot the labeled data points
    colors = [color_map[y] for y in y_train]
    plt.scatter(X[:, 0], X[:, 1], c=colors, edgecolors="black")

    plt.title(title)

plt.suptitle("Unlabeled points are colored white", y=0.1)
plt.show()

Sommaire

Dans ce laboratoire, nous avons exploré des classifieurs semi-supervisés sur l'ensemble de données Iris. Nous avons comparé les limites de décision générées par Label Spreading, Self-training et SVM sur l'ensemble de données Iris. Nous avons utilisé scikit-learn pour implémenter les classifieurs et visualiser les limites de décision. Nous avons constaté que Label Spreading et Self-training peuvent apprendre de bonnes limites de décision même lorsqu'il y a peu de données étiquetées disponibles.