Auto-training

Fonctions :

SelfTrainingClassifier()

La fonction SelfTrainingClassifier() de sklearn.semi_supervised permet de réaliser un apprentissage semi-supervisé en utilisant un modèle de base et en l'ajustant à un ensemble de données étiquetées et non étiquetées. L'idée derrière l'apprentissage semi-supervisé est que les données non étiquetées peuvent être utilisées pour améliorer la performance du modèle, en particulier lorsque la quantité de données étiquetées est limitée. Le classificateur utilise un modèle d'apprentissage supervisé pour entraîner les données étiquetées, puis itère sur les données non étiquetées, en attribuant des étiquettes à celles qui sont les plus confiantes selon le modèle, et en les ajoutant aux données d'entraînement.

Importation :

from sklearn.semi_supervised import SelfTrainingClassifier

Attributs :

Paramètre	Description
`base_estimator`	Le classificateur de base (modèle supervisé) qui sera utilisé pour l'apprentissage, par exemple un SVM ou un arbre de décision. Par défaut, c'est un classificateur `DecisionTreeClassifier`.
`criterion`	Critère utilisé pour évaluer la qualité des splits dans le classificateur de base (pertinent uniquement pour certains modèles comme les arbres de décision). Par défaut, c'est "gini" pour les arbres de décision.
`max_iter`	Le nombre maximum d'itérations pour la propagation des étiquettes. Par défaut, c'est 30. Cela signifie qu'une fois que le modèle a étiqueté un certain nombre de données non étiquetées, il peut arrêter l'apprentissage avant d'atteindre ce nombre d'itérations.
`threshold`	Le seuil de confiance pour qu'un modèle étiquette une donnée non étiquetée. Si la probabilité prédit un label avec une confiance inférieure à ce seuil, il ne sera pas étiqueté. Par défaut, c'est 0.8.
`verbose`	Si `True`, affiche des informations supplémentaires sur les itérations. Par défaut, c'est `False`.
`n_jobs`	Le nombre de processus à utiliser pour l'apprentissage parallèle. Par défaut, c'est `None`.

Exemple de code :

import numpy as np
from sklearn.datasets import make_classification
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Générer un jeu de données supervisé
X, y = make_classification(n_samples=500, n_features=20, n_classes=2, random_state=42)

# Simuler des labels manquants en rendant 50% des labels inconnus (-1)
rng = np.random.RandomState(42)
random_unlabeled_points = rng.rand(len(y)) < 0.5
y[random_unlabeled_points] = -1  # -1 = non étiqueté pour SelfTrainingClassifier

# Séparer en train/test (seulement pour évaluation)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Classifieur de base (supervisé)
base_clf = LogisticRegression(max_iter=1000)

# Modèle SelfTraining semi-supervisé
self_training_model = SelfTrainingClassifier(base_clf)

# Entraîner avec les labels partiels (-1 = non étiquetés)
self_training_model.fit(X_train, y_train)

# Prédictions sur le test
y_pred = self_training_model.predict(X_test)

# Évaluer le modèle
print(classification_report(y_test, y_pred))

Explication du code :

import numpy as np importe la bibliothèque NumPy pour la manipulation des tableaux numériques.

from sklearn.datasets import make_classification importe la fonction make_classification qui génère un jeu de données synthétique pour classification.

from sklearn.semi_supervised import SelfTrainingClassifier importe la classe SelfTrainingClassifier, un classifieur semi-supervisé qui s’auto-entraine sur des données partiellement étiquetées.

from sklearn.linear_model import LogisticRegression importe le modèle de régression logistique supervisé.

from sklearn.model_selection import train_test_split importe la fonction train_test_split qui sépare les données en ensembles d’entraînement et de test.

from sklearn.metrics import classification_report importe la fonction pour évaluer la performance du modèle avec un rapport détaillé.

Génération du jeu de données
 X, y = make_classification(n_samples=500, n_features=20, n_classes=2, random_state=42) génère un dataset synthétique avec 500 échantillons, 20 caractéristiques, et 2 classes. Simulation de labels manquants
 rng = np.random.RandomState(42) initialise un générateur aléatoire avec une graine fixe. random_unlabeled_points = rng.rand(len(y)) < 0.5 crée un masque booléen où environ 50 % des points sont sélectionnés aléatoirement. y[random_unlabeled_points] = -1 remplace ces labels par -1, indiquant des étiquettes inconnues pour le classifieur semi-supervisé. Séparation train/test
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) divise le jeu de données en 70 % entraînement et 30 % test, en conservant la reproductibilité. Définition du classifieur de base
 base_clf = LogisticRegression(max_iter=1000) crée un modèle de régression logistique avec un nombre maximum d’itérations fixé à 1000. Création du modèle SelfTraining semi-supervisé
 self_training_model = SelfTrainingClassifier(base_clf) enveloppe le classifieur supervisé dans un classifieur semi-supervisé capable d’utiliser les labels manquants. Entraînement du modèle semi-supervisé
 self_training_model.fit(X_train, y_train) entraîne le modèle en utilisant les labels partiels, en inférant progressivement les labels inconnus. Prédiction et évaluation
 y_pred = self_training_model.predict(X_test) prédit les classes sur l’ensemble de test. print(classification_report(y_test, y_pred)) affiche un rapport complet avec précision, rappel, F1-score et support pour chaque classe.
Ce code illustre comment exploiter un classifieur semi-supervisé pour apprendre sur des données où une partie des labels est manquante, en s’appuyant sur la confiance des prédictions du modèle de base.