Effet du seuil variable pour l'auto-formation

Introduction

Ce laboratoire illustre l'effet du seuil variable sur l'auto-entraînement. Le jeu de données breast_cancer est chargé et les étiquettes sont supprimées de sorte que seulement 50 échantillons sur 569 ont des étiquettes. Un SelfTrainingClassifier est ajusté sur ce jeu de données avec des seuils variables.

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 Carnet de notes 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

Importation des bibliothèques

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import StratifiedKFold
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.metrics import accuracy_score
from sklearn.utils import shuffle

Tout d'abord, nous allons importer les bibliothèques nécessaires pour ce laboratoire.

Chargement des données

X, y = datasets.load_breast_cancer(return_X_y=True)
X, y = shuffle(X, y, random_state=42)
y_true = y.copy()
y[50:] = -1
total_samples = y.shape[0]

Le jeu de données breast_cancer est chargé et mélangé. Nous copions ensuite les vraies étiquettes dans y_true et supprimons toutes les étiquettes de y sauf celles des 50 premiers échantillons. Cela servira à simuler un scénario d'apprentissage semi-supervisé.

Définition du classifieur

base_classifier = SVC(probability=True, gamma=0.001, random_state=42)

Nous définissons notre classifieur de base comme un Machine à Vecteurs de Support (SVM) avec une valeur basse de gamma de 0,001.

Définition des valeurs de seuil

x_values = np.arange(0.4, 1.05, 0.05)
x_values = np.append(x_values, 0.99999)

Nous définissons un tableau d valeurs de seuil allant de 0,4 à 1, avec des pas de 0,05. Nous ajoutons ensuite une valeur de seuil très élevée de 0,99999 pour nous assurer d inclure une valeur de seuil qui ne résultera en aucun échantillon auto-étiqueté.

Définition d tableaux pour les résultats

scores = np.empty((x_values.shape[0], n_splits))
amount_labeled = np.empty((x_values.shape[0], n_splits))
amount_iterations = np.empty((x_values.shape[0], n_splits))

Nous définissons des tableaux pour stocker les résultats de notre expérience.

Auto-formation avec un seuil variable

for i, threshold in enumerate(x_values):
    self_training_clf = SelfTrainingClassifier(base_classifier, threshold=threshold)

    skfolds = StratifiedKFold(n_splits=n_splits)
    for fold, (train_index, test_index) in enumerate(skfolds.split(X, y)):
        X_train = X[train_index]
        y_train = y[train_index]
        X_test = X[test_index]
        y_test = y[test_index]
        y_test_true = y_true[test_index]

        self_training_clf.fit(X_train, y_train)

        amount_labeled[i, fold] = (
            total_samples
            - np.unique(self_training_clf.labeled_iter_, return_counts=True)[1][0]
        )

        amount_iterations[i, fold] = np.max(self_training_clf.labeled_iter_)

        y_pred = self_training_clf.predict(X_test)
        scores[i, fold] = accuracy_score(y_test_true, y_pred)

Nous effectuons une auto-formation avec des seuils variables, en utilisant notre classifieur de base et la classe SelfTrainingClassifier de scikit-learn. Nous utilisons une validation croisée k-fold stratifiée pour diviser nos données en ensembles d'entraînement et de test. Nous ajustons ensuite le classifieur d auto-formation sur l ensemble d entraînement et calculons la précision du classifieur sur l ensemble de test. Nous stockons également le nombre d'échantillons étiquetés et le numéro d itération pour chaque plie.

Visualiser les résultats

ax1 = plt.subplot(211)
ax1.errorbar(
    x_values, scores.mean(axis=1), yerr=scores.std(axis=1), capsize=2, color="b"
)
ax1.set_ylabel("Précision", color="b")
ax1.tick_params("y", colors="b")

ax2 = ax1.twinx()
ax2.errorbar(
    x_values,
    amount_labeled.mean(axis=1),
    yerr=amount_labeled.std(axis=1),
    capsize=2,
    color="g",
)
ax2.set_ylim(bottom=0)
ax2.set_ylabel("Nombre d'échantillons étiquetés", color="g")
ax2.tick_params("y", colors="g")

ax3 = plt.subplot(212, sharex=ax1)
ax3.errorbar(
    x_values,
    amount_iterations.mean(axis=1),
    yerr=amount_iterations.std(axis=1),
    capsize=2,
    color="b",
)
ax3.set_ylim(bottom=0)
ax3.set_ylabel("Nombre d'itérations")
ax3.set_xlabel("Seuil")

plt.show()

Nous traçons les résultats de notre expérience à l'aide de Matplotlib. Le graphique supérieur montre le nombre d'échantillons étiquetés dont dispose le classifieur à la fin de l'ajustement, ainsi que la précision du classifieur. Le graphique inférieur montre la dernière itération au cours de laquelle un échantillon a été étiqueté.

Sommaire

Dans ce laboratoire, nous avons appris à effectuer une auto-formation avec des valeurs de seuil variables à l'aide de scikit-learn. Nous avons vu que la valeur optimale de seuil se situe entre des seuils très bas et très élevés, et que le choix d'une valeur de seuil appropriée peut entraîner des améliorations significatives de la précision.