Pseudo-labeling

Fonctions :

Pseudo-labeling (exemple)

Le pseudo-labelling est une technique d'apprentissage semi-supervisé où un modèle est d'abord entraîné sur un petit ensemble de données étiquetées. Ensuite, ce modèle est utilisé pour prédire des étiquettes pour un grand ensemble de données non étiquetées. Ces prédictions sont ensuite utilisées comme pseudo-étiquettes pour réentraîner le modèle. L'idée est que les prédictions d'un modèle déjà entraîné sur des données étiquetées peuvent être suffisamment fiables pour améliorer l'entraînement du modèle en utilisant des données non étiquetées. Cela permet de faire une utilisation optimale des données disponibles, même lorsque les données étiquetées sont limitées, ce qui est souvent le cas dans les problèmes réels.

Exemple de code :

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Création d'un jeu de données fictif
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# Simulation de données non étiquetées (par exemple, 40% des données sont non étiquetées)
y[400:] = -1  # -1 indique des étiquettes non étiquetées

# Séparation en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Création du classificateur
classifier = RandomForestClassifier(n_estimators=100, random_state=42)

# Phase d'apprentissage initiale sur les données étiquetées
classifier.fit(X_train[y_train != -1], y_train[y_train != -1])

# Méthode de Pseudo-labelling : générer des pseudo-étiquettes pour les données non étiquetées
pseudo_labels = classifier.predict(X_train[y_train == -1])
confidence_threshold = 0.9

# Application d'un seuil de confiance pour considérer les pseudo-étiquettes
probas = classifier.predict_proba(X_train[y_train == -1])
confident_indices = np.max(probas, axis=1) > confidence_threshold
y_train_copy = y_train.copy()

# Attribuer les pseudo-étiquettes uniquement pour les prédictions confiantes
y_train_copy[y_train == -1] = np.where(confident_indices, pseudo_labels, -1)

# Réentraîner le modèle avec les pseudo-étiquettes
classifier.fit(X_train[y_train_copy != -1], y_train_copy[y_train_copy != -1])

# Évaluation du modèle
y_pred = classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy with Pseudo-labelling: {accuracy:.4f}")

Explication du code :

import numpy as np importe la bibliothèque NumPy, utilisée ici pour la manipulation efficace des tableaux numériques.

from sklearn.datasets import make_classification importe la fonction make_classification, qui permet de générer un jeu de données synthétique pour un problème de classification.

from sklearn.model_selection import train_test_split importe la fonction train_test_split, utilisée pour diviser les données en ensembles d’entraînement et de test.

from sklearn.ensemble import RandomForestClassifier importe la classe RandomForestClassifier, un algorithme d’ensemble basé sur de multiples arbres de décision (bagging).

from sklearn.metrics import accuracy_score importe la fonction accuracy_score, utilisée pour évaluer la précision du modèle en comparant les prédictions avec les vraies étiquettes.

Création du jeu de données
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42) génère un jeu de 1000 échantillons avec 20 caractéristiques, répartis en 2 classes. Le paramètre random_state garantit la reproductibilité.

Simulation de données non étiquetées
y[400:] = -1 marque 60% des échantillons (à partir du 400e) comme non étiquetés en leur assignant la valeur -1, ce qui simule un contexte semi-supervisé.

Séparation en données d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) divise les données en 70% pour l’entraînement (avec et sans étiquettes) et 30% pour le test, de manière aléatoire mais reproductible.

Entraînement initial du modèle sur les données étiquetées
classifier = RandomForestClassifier(n_estimators=100, random_state=42) crée un modèle de forêt aléatoire avec 100 arbres, dont le comportement est reproductible via random_state.

classifier.fit(X_train[y_train != -1], y_train[y_train != -1]) entraîne le modèle uniquement sur les données étiquetées (où y ≠ -1), en ignorant les échantillons non étiquetés.

Génération des pseudo-étiquettes
pseudo_labels = classifier.predict(X_train[y_train == -1]) applique le modèle pour prédire des étiquettes provisoires (pseudo-labels) pour les données non étiquetées.

probas = classifier.predict_proba(X_train[y_train == -1]) retourne la probabilité de chaque classe prédite pour ces exemples non étiquetés.

Filtrage des prédictions selon un seuil de confiance
confidence_threshold = 0.9 définit un seuil à partir duquel une prédiction est jugée suffisamment fiable pour être utilisée.

confident_indices = np.max(probas, axis=1) > confidence_threshold repère les indices des exemples non étiquetés dont la probabilité maximale dépasse ce seuil, indiquant une prédiction confiante.

y_train_copy = y_train.copy() crée une copie du vecteur d’étiquettes afin de pouvoir le modifier sans altérer les données originales.

y_train_copy[y_train == -1] = np.where(confident_indices, pseudo_labels, -1) insère les pseudo-labels uniquement pour les échantillons jugés confiants, les autres restant marqués comme non étiquetés.

Réentraîner le modèle avec les pseudo-étiquettes fiables
classifier.fit(X_train[y_train_copy != -1], y_train_copy[y_train_copy != -1]) entraîne un nouveau modèle en combinant les données initialement étiquetées et les exemples non étiquetés ayant reçu une pseudo-étiquette confiante.

Évaluation du modèle
y_pred = classifier.predict(X_test) prédit les classes des données de test à l’aide du modèle final.

accuracy = accuracy_score(y_test, y_pred) calcule la proportion de prédictions correctes, donnant une mesure de la performance du modèle.

print(f"Accuracy with Pseudo-labelling: {accuracy:.4f}") affiche la précision du modèle avec 4 décimales, illustrant l’impact du pseudo-labelling.

Ce code met en œuvre la stratégie de Pseudo-labelling, une technique d’apprentissage semi-supervisé consistant à exploiter les prédictions les plus sûres d’un modèle pour étiqueter artificiellement des données non annotées. Cela permet d’augmenter la taille du jeu d’entraînement de manière contrôlée, tout en limitant les erreurs dues à de fausses étiquettes.