Co-training

Fonctions :

Co-training (exemple)

Le Co-training est une technique d’apprentissage semi-supervisé qui exploite deux (ou plusieurs) vues différentes des données, c’est-à-dire des ensembles de caractéristiques complémentaires. Chaque vue est utilisée pour entraîner un classificateur séparé. Ces deux classificateurs s’entraînent mutuellement en s’échangeant des pseudo-étiquettes sur les données non étiquetées, ce qui permet d’augmenter progressivement le volume de données étiquetées utilisées.

Exemple de code :

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
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_informative=10, 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 des classificateurs
classifier1 = SVC(probability=True, kernel='linear')
classifier2 = DecisionTreeClassifier()

# Initialisation des labels
y_train_1 = y_train.copy()
y_train_2 = y_train.copy()

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

# Co-training : itérations pour étiqueter les données non étiquetées
for iteration in range(10):
    # Utilisation de classifier1 pour étiqueter les données non étiquetées
    probas1 = classifier1.predict_proba(X_train[y_train == -1])
    confident1 = np.max(probas1, axis=1) > 0.9  # Si la prédiction est confiante
    y_train_1[y_train == -1] = np.where(confident1, classifier1.predict(X_train[y_train == -1]), -1)

    # Utilisation de classifier2 pour étiqueter les données non étiquetées
    probas2 = classifier2.predict_proba(X_train[y_train == -1])
    confident2 = np.max(probas2, axis=1) > 0.9  # Si la prédiction est confiante
    y_train_2[y_train == -1] = np.where(confident2, classifier2.predict(X_train[y_train == -1]), -1)

    # Réentraîner les classificateurs sur les données étiquetées augmentées
    classifier1.fit(X_train[y_train_1 != -1], y_train_1[y_train_1 != -1])
    classifier2.fit(X_train[y_train_2 != -1], y_train_2[y_train_2 != -1])

# Évaluation du modèle
y_pred = classifier1.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy after Co-training: {accuracy:.4f}")

Explication du code :

import numpy as np importe la bibliothèque NumPy pour la gestion efficace 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 des tâches de classification.

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

from sklearn.svm import SVC importe le classifieur SVC (Support Vector Classifier) basé sur les machines à vecteurs de support.

from sklearn.tree import DecisionTreeClassifier importe le classifieur par arbre de décision.

from sklearn.metrics import accuracy_score importe la fonction pour calculer la précision d’un modèle.

Création d’un jeu de données
 X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_classes=2, random_state=42) génère un dataset avec 1000 échantillons, 20 caractéristiques dont 10 informatives, répartis en 2 classes. Simulation de données non étiquetées
 y[400:] = -1 remplace les labels des 600 derniers échantillons par -1, indiquant qu’ils sont non étiquetés. 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 les données en 70 % pour l’entraînement et 30 % pour le test. Création des deux classificateurs
 classifier1 = SVC(probability=True, kernel='linear') crée un classifieur SVM linéaire avec estimation de probabilité activée. classifier2 = DecisionTreeClassifier() crée un classifieur par arbre de décision. Initialisation des labels pour chaque classifieur
 y_train_1 = y_train.copy() et y_train_2 = y_train.copy() font des copies indépendantes des labels pour chaque classifieur, pour gérer séparément leurs étiquetages. Phase d’apprentissage initiale
 classifier1.fit(X_train[y_train != -1], y_train[y_train != -1]) et classifier2.fit(X_train[y_train != -1], y_train[y_train != -1]) entraînent les classifieurs uniquement sur les données étiquetées (labels != -1). Itérations de Co-training
 Pour iteration in range(10) (10 tours) : - probas1 = classifier1.predict_proba(X_train[y_train == -1]) prédit les probabilités de classe sur les données non étiquetées avec le classifieur 1. - confident1 = np.max(probas1, axis=1) > 0.9 identifie les prédictions très confiantes (probabilité max > 0.9). - y_train_1[y_train == -1] = np.where(confident1, classifier1.predict(X_train[y_train == -1]), -1) assigne des labels prévus uniquement si la confiance est élevée, sinon garde -1.
Même procédé est appliqué avec le classifieur 2 :

probas2 = classifier2.predict_proba(X_train[y_train == -1])

confident2 = np.max(probas2, axis=1) > 0.9

y_train_2[y_train == -1] = np.where(confident2, classifier2.predict(X_train[y_train == -1]), -1)

Enfin, les classifieurs sont ré-entrainés sur les labels augmentés :

classifier1.fit(X_train[y_train_1 != -1], y_train_1[y_train_1 != -1])

classifier2.fit(X_train[y_train_2 != -1], y_train_2[y_train_2 != -1])

Évaluation finale
 y_pred = classifier1.predict(X_test) prédit les classes du jeu de test avec le classifieur 1 final. accuracy = accuracy_score(y_test, y_pred) calcule la précision. print(f"Accuracy after Co-training: {accuracy:.4f}") affiche la précision obtenue.
Ce code illustre la méthode Co-training, où deux classifieurs collaborent pour labelliser des données non étiquetées avec confiance élevée, augmentant ainsi leurs données d’apprentissage respectives et améliorant la performance sur un problème semi-supervisé.