Graph-based learning

Fonctions :

LabelPropagation()

La fonction LabelPropagation() de sklearn.semi_supervised implémente un algorithme d'apprentissage semi-supervisé qui permet de prédire les étiquettes des données non étiquetées en utilisant des informations provenant des étiquettes de données étiquetées. L'algorithme fonctionne en propagant les étiquettes à travers un graphe de similarités entre les échantillons. Les échantillons étiquetés sont utilisés pour initier la propagation, et les étiquettes sont ensuite propagées aux voisins les plus similaires dans le graphe. Cela permet au modèle d'apprendre à partir de données étiquetées et non étiquetées.

Importation :

from sklearn.semi_supervised import LabelPropagation

Attributs :

Paramètre	Description
`kernel`	Le type de noyau à utiliser pour construire le graphe de similarité. Les options sont 'rbf' (par défaut), 'knn' et 'cosine'.
`gamma`	Paramètre du noyau RBF. Plus la valeur est élevée, plus l'influence des voisins proches est grande. Ignoré si le noyau n'est pas 'rbf'. Par défaut, c'est 1 / n_features.
`n_neighbors`	Le nombre de voisins à utiliser pour le noyau 'knn' (k plus proches voisins) pour calculer les similarités. Par défaut, c'est 7.
`max_iter`	Le nombre maximum d'itérations de propagation des étiquettes. Par défaut, c'est 30.
`tol`	Le critère de tolérance pour arrêter l'itération. Si la différence entre les nouvelles et anciennes étiquettes est inférieure à cette tolérance, l'algorithme s'arrête. Par défaut, c'est 1e-3.
`n_jobs`	Le nombre de processus à utiliser pour calculer les similarités. Par défaut, c'est None (utilise un seul processus).
`verbose`	Si True, affiche des informations supplémentaires pendant l'exécution de l'algorithme. Par défaut, c'est False.
`random_state`	Contrôle la reproductibilité des résultats. Il est utilisé pour initialiser le générateur de nombres aléatoires. Par défaut, c'est None.

Exemple de code :

# Importation des bibliothèques nécessaires
from sklearn.datasets import make_classification
from sklearn.semi_supervised import LabelPropagation
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

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

# Simulation de données non étiquetées (par exemple, 20% des données sont non étiquetées)
y[200:] = -1  # -1 indique que la donnée est non étiquetée

# 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 LabelPropagation
label_propagation_model = LabelPropagation(kernel='rbf', max_iter=100)

# Entraînement du modèle sur les données étiquetées et non étiquetées
label_propagation_model.fit(X_train, y_train)

# Prédictions sur les données de test
y_pred = label_propagation_model.predict(X_test)

# Évaluation de la précision
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.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.