Ensemble de chaînes de classifieurs

Introduction

Ce laboratoire démontre un exemple d'utilisation de la chaîne de classifieurs sur un ensemble de données multilabel. L'algorithme de chaîne de classifieurs est une modification de la méthode de transformation du problème pour la classification multilabel. Cette méthode exploite la corrélation entre les classes en construisant une chaîne de classifieurs binaires. Chaque modèle reçoit les prédictions des modèles précédents dans la chaîne en tant que caractéristiques. Nous utiliserons l'ensemble de données yeast qui contient 2417 points de données, chacun avec 103 caractéristiques et 14 étiquettes possibles. Chaque point de données a au moins une étiquette. En tant que référence, nous entraînons tout d'abord un classifieur de régression logistique pour chacune des 14 étiquettes. Pour évaluer les performances de ces classifieurs, nous prédisons sur un ensemble de test séparé et calculons le score de Jaccard pour chaque échantillon.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Charger l'ensemble de données yeast

X, Y = fetch_openml("yeast", version=4, return_X_y=True, parser="pandas")
Y = Y == "TRUE"
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)

Entraîner un modèle de régression logistique indépendant pour chaque classe

base_lr = LogisticRegression()
ovr = OneVsRestClassifier(base_lr)
ovr.fit(X_train, Y_train)
Y_pred_ovr = ovr.predict(X_test)
ovr_jaccard_score = jaccard_score(Y_test, Y_pred_ovr, average="samples")

Entraîner un ensemble de chaînes de classifieurs de régression logistique

chains = [ClassifierChain(base_lr, order="random", random_state=i) for i in range(10)]
for chain in chains:
    chain.fit(X_train, Y_train)

Y_pred_chains = np.array([chain.predict(X_test) for chain in chains])
chain_jaccard_scores = [
    jaccard_score(Y_test, Y_pred_chain >= 0.5, average="samples")
    for Y_pred_chain in Y_pred_chains
]

Calculer la prédiction moyenne de toutes les chaînes

Y_pred_ensemble = Y_pred_chains.mean(axis=0)
ensemble_jaccard_score = jaccard_score(
    Y_test, Y_pred_ensemble >= 0.5, average="samples"
)

Tracer les scores de similarité de Jaccard

model_scores = [ovr_jaccard_score] + chain_jaccard_scores
model_scores.append(ensemble_jaccard_score)

model_names = (
    "Independent",
    "Chaîne 1",
    "Chaîne 2",
    "Chaîne 3",
    "Chaîne 4",
    "Chaîne 5",
    "Chaîne 6",
    "Chaîne 7",
    "Chaîne 8",
    "Chaîne 9",
    "Chaîne 10",
    "Ensemble",
)

x_pos = np.arange(len(model_names))

fig, ax = plt.subplots(figsize=(7, 4))
ax.grid(True)
ax.set_title("Comparaison des performances de l'ensemble de chaînes de classifieurs")
ax.set_xticks(x_pos)
ax.set_xticklabels(model_names, rotation="vertical")
ax.set_ylabel("Score de similarité de Jaccard")
ax.set_ylim([min(model_scores) * 0.9, max(model_scores) * 1.1])
colors = ["r"] + ["b"] * len(chain_jaccard_scores) + ["g"]
ax.bar(x_pos, model_scores, alpha=0.5, color=colors)
plt.tight_layout()
plt.show()

Sommaire

Ce laboratoire a montré comment utiliser l'algorithme de chaîne de classifieurs pour construire un ensemble de chaînes de classifieurs de régression logistique afin d'exploiter les corrélations entre les classes. Le score de similarité de Jaccard pour chaque chaîne tend à être supérieur à celui des modèles de régression logistique indépendants. Enfin, nous avons construit un ensemble de vote de chaînes de classifieurs en calculant la moyenne des prédictions binaires des chaînes et en appliquant un seuil de 0,5. Le score de similarité de Jaccard de l'ensemble est supérieur à celui des modèles indépendants et tend à dépasser le score de chaque chaîne dans l'ensemble.