Label Propagation et Label Spreading

Les méthodes Label Propagation et Label Spreading sont deux techniques d’apprentissage semi-supervisé utilisées pour prédire les étiquettes des données non étiquetées en se basant sur des graphes. Ces algorithmes exploitent les relations entre les échantillons de données pour propager les étiquettes des échantillons étiquetés vers les échantillons non étiquetés.

Fonctions :

LabelPropagation()

L'algorithme de Label Propagation est une technique d'apprentissage semi-supervisé qui fonctionne sur un graphe de similarité entre les points de données. L'idée principale est que les points de données similaires devraient avoir les mêmes étiquettes. L'algorithme part de données étiquetées et essaie de propager ces étiquettes vers les autres données non étiquetées en suivant la structure du graphe. Au fur et à mesure des itérations, les étiquettes se propagent dans le graphe jusqu'à ce qu'un état de convergence soit atteint.

Importation :

from sklearn.semi_supervised import LabelPropagation

Attributs :

Paramètre	Description
`kernel`	Type de noyau utilisé pour la construction du graphe de similarité. Il peut être "rbf", "knn", ou "linear".
`gamma`	Paramètre pour le noyau RBF. Il influence la largeur de la fonction gaussienne. Un gamma faible donne un graphe plus dense.
`max_iter`	Le nombre maximal d'itérations que l'algorithme peut effectuer pour propager les étiquettes.
`tol`	Seuil de convergence. Si la différence entre les étiquettes entre deux itérations successives est inférieure à ce seuil, l'algorithme s'arrête.
`n_neighbors`	Le nombre de voisins à considérer pour construire le graphe lorsque le noyau est "knn".

Exemple de code :

from sklearn.semi_supervised import LabelPropagation
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

# 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
y[500:] = -1  # 50% des données sont non étiquetées

# Séparation des données étiquetées et non étiquetées
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Application de Label Propagation
label_prop = LabelPropagation(kernel='rbf')
label_prop.fit(X_train, y_train)

# Prédictions
y_pred = label_prop.predict(X_test)

# Affichage de la précision
from sklearn.metrics import accuracy_score
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")

Explication du code :

from sklearn.datasets import make_classification importe la fonction make_classification qui génère un jeu de données synthétique pour des tâches de classification, avec un certain nombre de caractéristiques informatives et redondantes.

from sklearn.semi_supervised import LabelPropagation importe la classe LabelPropagation du module semi-supervisé de scikit-learn, qui implémente un algorithme permettant de propager les étiquettes connues à travers un graphe de similarité vers les données non étiquetées.

from sklearn.model_selection import train_test_split importe la fonction train_test_split qui divise un jeu de données en deux ensembles distincts (entraînement et test), facilitant ainsi l’évaluation des performances du modèle.

from sklearn.metrics import accuracy_score importe la fonction accuracy_score qui calcule la précision d’un modèle en comparant les étiquettes prédites avec les vraies étiquettes.

Création d’un jeu de données synthétique
 X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_classes=3, random_state=42) génère un jeu de données contenant 1000 échantillons, chacun ayant 20 caractéristiques, dont 10 sont réellement informatives pour distinguer entre 3 classes différentes. Le paramètre random_state permet de rendre les résultats reproductibles.
Simulation de données non étiquetées
 y[200:] = -1 remplace les étiquettes de 800 exemples (à partir du 201e) par -1, ce qui signifie que ces données sont considérées comme non étiquetées pour l’apprentissage semi-supervisé.
Séparation du jeu de données
 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 deux ensembles : 70% pour l’entraînement (y compris les exemples non étiquetés) et 30% pour le test. Cette séparation permet d’évaluer la performance du modèle sur des données totalement nouvelles.
Création du modèle LabelPropagation
 label_propagation_model = LabelPropagation(kernel='rbf', max_iter=100) crée un modèle LabelPropagation en utilisant un noyau radial (rbf) pour mesurer la similarité entre les échantillons, et limite le nombre d’itérations de propagation à 100.
Entraînement du modèle
 label_propagation_model.fit(X_train, y_train) ajuste le modèle LabelPropagation sur les données d'entraînement contenant à la fois des étiquettes connues et inconnues. Le modèle propage les labels connus aux exemples non étiquetés en se basant sur leur proximité dans l’espace des caractéristiques.
Prédiction sur les données de test
 y_pred = label_propagation_model.predict(X_test) applique le modèle appris pour prédire les classes des données de test (initialement connues mais non utilisées dans l’apprentissage).
Évaluation de la précision
 accuracy = accuracy_score(y_test, y_pred) calcule la précision globale du modèle en comparant les prédictions avec les vraies étiquettes du jeu de test. print(f"Accuracy: {accuracy:.4f}") affiche cette précision avec 4 chiffres après la virgule.
Ce code illustre comment un modèle semi-supervisé comme LabelPropagation peut tirer parti d’un petit sous-ensemble de données étiquetées pour généraliser à l’ensemble du jeu, en propageant les étiquettes aux exemples similaires dans un espace de caractéristiques partagé. C’est particulièrement utile lorsqu’on dispose de peu de données annotées mais de nombreuses données brutes.

LabelSpreading()

Le Label Spreading est une variante de Label Propagation. Alors que Label Propagation effectue une propagation brute des étiquettes dans un graphe, Label Spreading introduit un facteur de régularisation, ce qui permet d'éviter des étiquettes instables ou trop influencées par des points éloignés dans le graphe. Cela rend l'algorithme plus stable et permet de mieux gérer les situations où les relations entre les points de données sont moins évidentes. Le facteur de régularisation dans Label Spreading peut rendre les résultats moins sensibles aux points étiquetés bruyants.

Importation :

from sklearn.semi_supervised import LabelSpreading

Attributs :

Paramètre	Description
`kernel`	Type de noyau utilisé pour la construction du graphe de similarité. Il peut être "rbf", "knn", ou "precomputed".
`gamma`	Paramètre pour le noyau RBF. Il influence la largeur de la fonction gaussienne. Un gamma faible donne un graphe plus dense.
`max_iter`	Le nombre maximal d'itérations que l'algorithme peut effectuer pour propager les étiquettes.
`tol`	Seuil de convergence. Si la différence entre les étiquettes entre deux itérations successives est inférieure à ce seuil, l'algorithme s'arrête.
`n_neighbors`	Le nombre de voisins à considérer pour construire le graphe lorsque le noyau est "knn".
`alpha`	Facteur de régularisation. Un alpha plus élevé rend le modèle plus influencé par les points étiquetés.

Exemple de code :

from sklearn.semi_supervised import LabelSpreading
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

# 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
y[500:] = -1  # 50% des données sont non étiquetées

# Séparation des données étiquetées et non étiquetées
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Application de Label Spreading
label_spread = LabelSpreading(kernel='rbf', alpha=0.8)
label_spread.fit(X_train, y_train)

# Prédictions
y_pred = label_spread.predict(X_test)

# Affichage de la précision
from sklearn.metrics import accuracy_score
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")

Explication du code :

from sklearn.semi_supervised import LabelSpreading importe la classe LabelSpreading, un algorithme d’apprentissage semi-supervisé. Il repose sur un modèle de propagation des étiquettes dans un graphe de similarité entre les points de données, en supposant que les points proches partagent la même étiquette. Contrairement à LabelPropagation, ce modèle introduit une régularisation via un paramètre alpha.

from sklearn.datasets import make_classification importe la fonction make_classification, qui génère un jeu de données synthétique destiné à des tâches de classification. Elle permet de spécifier le nombre d’échantillons, de caractéristiques, et de classes.

from sklearn.model_selection import train_test_split importe la fonction train_test_split, utilisée pour diviser les données en deux sous-ensembles : un pour l'entraînement, un pour le test. Cela permet d’évaluer les performances du modèle sur des données jamais vues.

import numpy as np importe la bibliothèque NumPy, utilisée ici pour manipuler efficacement les tableaux de données. Elle permet, par exemple, d’assigner des valeurs d’étiquettes spéciales (comme -1 pour indiquer une absence d’étiquette).

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 ensemble de 1000 échantillons, chacun avec 20 caractéristiques numériques. Les échantillons sont répartis entre 2 classes. Le paramètre random_state=42 assure la reproductibilité des résultats. Simulation de données non étiquetées
 y[500:] = -1 remplace les étiquettes de la moitié des données (les 500 dernières) par -1, ce qui indique qu’elles sont considérées comme non étiquetées. Cette opération simule un environnement d’apprentissage 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 le jeu de données en 70% pour l’entraînement et 30% pour le test, tout en maintenant la proportion des classes. Cela permet de mesurer la capacité du modèle à généraliser sur des données nouvelles. Application de Label Spreading
 label_spread = LabelSpreading(kernel='rbf', alpha=0.8) instancie le modèle Label Spreading avec un noyau RBF (Radial Basis Function), qui mesure la similarité entre les échantillons. Le paramètre alpha=0.8 contrôle la quantité de régularisation : plus il est proche de 1, plus les étiquettes initiales sont respectées.
label_spread.fit(X_train, y_train) entraîne le modèle en propageant les étiquettes connues aux données non étiquetées en se basant sur la structure du graphe de similarité.

Prédiction sur les données de test
 y_pred = label_spread.predict(X_test) prédit les étiquettes des échantillons de test à l’aide du modèle entraîné. Ces prédictions peuvent inclure aussi bien des classes d’origine que des estimations faites par propagation. Évaluation du modèle
 from sklearn.metrics import accuracy_score importe la fonction accuracy_score, qui permet d’évaluer la précision de prédiction du modèle.
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}") calcule la précision en comparant les étiquettes prédites à celles attendues sur le jeu de test. Le score est affiché avec une précision de quatre décimales.

Ce code illustre une approche d’apprentissage semi-supervisé dans laquelle une portion significative des données ne possède pas d’étiquette. Le modèle Label Spreading exploite la structure du graphe formé par les données pour diffuser l’information des étiquettes connues vers celles qui ne le sont pas. Cette méthode permet d’améliorer les performances dans les cas où l’annotation manuelle est coûteuse ou partiellement disponible.