Co-training

Le Co-Training est une méthode d’apprentissage semi-supervisé utilisée pour améliorer la performance des modèles lorsque seules certaines données sont étiquetées. L’objectif est de tirer parti des données non étiquetées en combinant les prédictions de plusieurs modèles ou vues différentes des données.

Le principe consiste à entraîner deux modèles distincts sur des sous-ensembles de caractéristiques différents. Chaque modèle prédit les étiquettes des données non étiquetées, puis les prédictions les plus fiables de chaque modèle sont ajoutées au jeu de données étiquetées de l’autre modèle. Ce processus est répété de manière itérative pour améliorer la précision globale.

Le Co-Training est utilisé en science des données, traitement du langage naturel, vision par ordinateur et autres domaines où l’annotation complète des données est coûteuse ou difficile.

La performance du modèle peut être évaluée à l’aide de métriques classiques d’apprentissage supervisé, comme l’exactitude, la précision, le rappel ou la F1-score.

En résumé, le Co-Training permet d’améliorer les modèles en exploitant des données non étiquetées à partir de plusieurs perspectives ou sous-ensembles de caractéristiques.

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}")
    Résultat du code

    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é.

⚠️ Ce contenu est réservé aux membres Premium

Abonnez-vous pour débloquer cette page et accéder à tous nos contenus exclusifs.

Souscrire maintenant