Contexte
Dans cette expérience, nous avons utilisé deux modèles de classification pour effectuer une tâche de
classification d'iris : un Arbre de Décision implémenté manuellement et avec scikit-learn, ainsi qu'un
Réseau de Neurones. Nous avons ensuite évalué chaque modèle en termes de plusieurs métriques de
performance, notamment l'exactitude (accuracy), la précision (precision), le rappel (recall), le F1-score et la
matrice de confusion.
Résultats de l'Arbre de Décision (Implémentation Manuelle)
L'implémentation manuelle de l'arbre de décision a produit les résultats suivants sur le dataset de test :
Exactitude (Accuracy) : 93.33%
L'exactitude du modèle est très élevée, ce qui signifie que le modèle a correctement classé 93.33%
des échantillons de test.
Précision (Precision) : [1.0, 0.8, 1.0]
La précision est excellente pour les classes 1 et 3, atteignant 1.0, ce qui indique que toutes les
prédictions faites pour ces classes étaient correctes. La précision pour la classe 2 est plus faible (0.8),
ce qui suggère quelques erreurs dans la classification de cette classe.
Rappel (Recall) : [1.0, 1.0, 0.8]
Le modèle a un rappel parfait (1.0) pour les classes 1 et 2, ce qui signifie qu'il a correctement
identifié toutes les instances de ces classes. Cependant, le rappel pour la classe 3 est de 0.8, ce qui
indique que certaines instances de cette classe n'ont pas été identifiées.
F1-Score : [1.0, 0.89, 0.89]
Le F1-score est élevé pour les classes 1 et 3, ce qui reflète un bon compromis entre précision et
rappel. La classe 2 présente un F1-score un peu plus faible, ce qui est en cohérence avec sa précision
et son rappel moins optimaux.
Matrice de confusion :
[[18 0 0]
[ 0 12 0]
[ 0 3 12]]
La matrice montre que le modèle a correctement prédit la classe 1 avec 18 instances correctement
classées. La classe 2 présente quelques erreurs de classification avec 3 erreurs, et la classe 3 présente
3 erreurs également, mais globalement, les erreurs sont faibles.
Résultats du Réseau de Neurones
Le réseau de neurones a donné les résultats suivants :
Exactitude (Accuracy) : 73.33%
L'exactitude du réseau de neurones est bien inférieure à celle de l'arbre de décision (93.33%). Ce
modèle montre une performance plus modeste.
Précision (Precision) : [0.9, 0.625, 0.59]
Le réseau de neurones est assez précis pour la classe 1 (0.9), mais la précision chute pour la classe 2
(0.625) et la classe 3 (0.59). Cela montre que le modèle a du mal à bien classifier certaines classes.
Rappel (Recall) : [1.0, 0.42, 0.67]
Bien que le modèle identifie toutes les instances de la classe 1 (rappel = 1.0), il est moins performant
pour la classe 2, avec un rappel de seulement 0.42. Le rappel pour la classe 3 est plus élevé (0.67),
mais il reste insuffisant pour obtenir une classification fiable.
F1-Score : [0.95, 0.5, 0.625]
Le F1-score pour la classe 1 est élevé, mais celui pour les classes 2 et 3 est nettement plus faible,
indiquant un déséquilibre dans la capacité du modèle à traiter toutes les classes de manière équitable.
Matrice de confusion :
[[18 0 0]
[ 0 5 7]
[ 2 3 10]]
La matrice de confusion montre que le réseau de neurones est parfait pour la classe 1 (18 bonnes
classifications). Il y a quelques erreurs dans la classification de la classe 2 (5 bonnes classifications et
7 erreurs) et des erreurs plus notables pour la classe 3.
Résultats de l'Arbre de Décision avec scikit-learn
L'utilisation de la classe DecisionTreeClassifier de scikit-learn a donné des résultats impressionnants :
Exactitude (Accuracy) : 93.33%
Le modèle scikit-learn atteint la même exactitude que l'implémentation manuelle de l'arbre de décision
(93.33%), ce qui montre qu'il est aussi performant pour cette tâche spécifique.
Précision (Precision) : 0.93
La précision pour scikit-learn est élevée, indiquant que le modèle a bien classé les instances pour toutes les
classes.
Rappel (Recall) : 0.93
Le modèle scikit-learn montre un excellent rappel global, ce qui signifie qu'il a bien capté la majorité des
instances de chaque classe.
F1-Score : 0.93
Le F1-score élevé indique un bon compromis entre précision et rappel, ce qui confirme que le modèle est
équilibré dans ses performances.
Matrice de confusion :
[[18 0 0]
[ 0 12 0]
[ 0 3 12]]
La matrice de confusion est presque identique à celle de l'implémentation manuelle de l'arbre de décision, ce
qui montre que le modèle de scikit-learn fait un excellent travail dans la classification des classes 1 et 2,
avec des erreurs mineures dans la classe 3.
Comparaison entre l'implémentation manuelle de l’arbre de décision et scikit-learn :
Exactitude : Les deux modèles (implémentation manuelle et scikit-learn) ont une exactitude
identique de 93.33%.
Précision, Rappel, et F1-Score : Les performances de précision, de rappel et de F1-score sont
presque identiques entre les deux modèles, avec des valeurs très proches. Cela suggère que
l'implémentation manuelle de l'arbre de décision atteint un niveau de performance similaire à celui
de l'arbre de décision de scikit-learn.
Conclusion :
1. Arbre de Décision (Implémentation Manuelle et Scikit-learn) :
Les deux modèles d'arbre de décision ont montré une excellente performance, avec des scores
similaires. Les deux ont une exactitude de 93.33%, et le compromis entre précision et rappel est bien
équilibré, ce qui montre qu'ils sont très efficaces pour cette tâche de classification.
2. Réseau de Neurones :
Le réseau de neurones présente des performances plus faibles en comparaison, avec une exactitude
de seulement 73.33%. Bien qu'il ait un bon rappel pour la classe 1, il est moins performant pour les
autres classes, notamment la classe 2, ce qui indique des difficultés à généraliser correctement.
En conclusion, l'arbre de décision, qu'il soit implémenté manuellement ou avec scikit-learn, offre des
performances exceptionnelles avec une exactitude de 93.33%, surpassant largement le réseau de neurones
(73.33%). Ces résultats montrent que les arbres de décision sont particulièrement bien adaptés à cette tâche
de classification, offrant un excellent compromis entre précision, rappel et F1-score.
Courbe d’apprentissage de l’arbre de décision et son analyse :
Le graphique montre que l'erreur d'entraînement devient nulle et reste constante, ce qui signifie que l'arbre
de décision réussit à parfaitement classer tous les exemples d'entraînement. Cela indique que l'algorithme a
bien appris les données d'entraînement, mais il est possible que l'arbre ait mémorisé les exemples spécifiques
de ces données. Cela peut être un signe de sur-apprentissage, où le modèle apprend non seulement les
tendances générales, mais aussi les particularités et bruits présents dans les données d'entraînement.
L'erreur de test, qui diminue progressivement puis se stabilise, montre que l'arbre de décision commence à
mieux prédire les données de test au fur et à mesure que de nouveaux exemples sont ajoutés. Cependant, une
fois l'erreur de test stabilisée, cela suggère que l'ajout d'exemples d'entraînement supplémentaires n'améliore
plus significativement les performances sur les données de test. Cela peut signifier que le modèle a atteint un
point où il généralise suffisamment bien aux nouvelles données.
Cela montre que l'arbre a appris une relation entre les caractéristiques et les étiquettes dans les données
d'entraînement, mais il pourrait aussi avoir atteint un stade où il devient incapable d'améliorer davantage ses
performances sur de nouvelles données, indiquant un équilibre atteint entre l'apprentissage des données et la
capacité à généraliser.
.
Commentaires sur les résultats
Résultats pour Iris :
Premier ensemble :
o 4 neurones → erreur moyenne : 74.29%
o 8 neurones → erreur moyenne : 74.29%
o 16 neurones → erreur moyenne : 74.29%
o 32 neurones → erreur moyenne : 74.29%
o 64 neurones → erreur moyenne : 65.71%
Deuxième ensemble :
o 4 neurones → erreur moyenne : 70.48%
o 8 neurones → erreur moyenne : 70.48%
o 16 neurones → erreur moyenne : 64.76%
o 32 neurones → erreur moyenne : 70.48%
o 64 neurones → erreur moyenne : 74.29%
Analyse :
Le modèle montre une amélioration significative uniquement avec 64 neurones dans le premier ensemble,
mais les performances chutent à nouveau dans le deuxième ensemble. Cela indique une instabilité dans
l'apprentissage.
La meilleure dimension semble être 16 neurones, car elle présente une réduction notable de l'erreur dans le
deuxième ensemble (64.76%).
Résultats pour Wine :
Premier ensemble :
o 4 neurones → erreur moyenne : 48.06%
o 8 neurones → erreur moyenne : 43.83%
o 16 neurones → erreur moyenne : 39.39%
o 32 neurones → erreur moyenne : 47.49%
o 64 neurones → erreur moyenne : 42.88%
Deuxième ensemble :
o 4 neurones → erreur moyenne : 43.62%
o 8 neurones → erreur moyenne : 39.81%
o 16 neurones → erreur moyenne : 42.77%
o 32 neurones → erreur moyenne : 47.53%
o 64 neurones → erreur moyenne : 47.28%
Analyse :
Le modèle atteint une erreur minimale avec 16 neurones dans le premier ensemble (39.39%).
Toutefois, les performances sont légèrement inférieures dans le deuxième ensemble pour cette même
dimension.
La meilleure dimension semble être 8 neurones, car elle offre un bon compromis entre les deux ensembles
avec une erreur moyenne basse (39.81% dans le deuxième ensemble).
Résultats pour Abalone :
Premier ensemble :
o 4 neurones → erreur moyenne : 21.55%
o 8 neurones → erreur moyenne : 21.55%
o 16 neurones → erreur moyenne : 21.55%
o 32 neurones → erreur moyenne : 21.55%
o 64 neurones → erreur moyenne : 21.55%
Deuxième ensemble :
o 4 neurones → erreur moyenne : 22.48%
o 8 neurones → erreur moyenne : 22.48%
o 16 neurones → erreur moyenne : 22.48%
o 32 neurones → erreur moyenne : 22.48%
o 64 neurones → erreur moyenne : 22.48%
Analyse :
Les erreurs restent constantes, quelle que soit la dimension de la couche cachée. Cela suggère que le modèle
est incapable d'apprendre des relations plus complexes dans les données.
Cela peut indiquer un problème structurel, tel que des données mal normalisées, une trop faible capacité de
représentation, ou un sur-apprentissage dès les premières itérations.
Choix des dimensions pour chaque dataset
1. Iris :
La meilleure dimension semble être 16 neurones, car elle réduit significativement l'erreur dans l'un
des ensembles.
2. Wine :
Une dimension de 8 neurones offre le meilleur compromis entre stabilité et performance dans les
deux ensembles.
3. Abalone :
Étant donné l'absence d'amélioration, il est raisonnable de conserver une petite dimension comme 4
neurones, pour éviter une complexité inutile.
Modèle à choisir pour chaque dataset
Iris : Modèle avec 16 neurones dans la couche cachée, avec un taux de dropout de 0.5 pour éviter le
surapprentissage.
Wine : Modèle avec 8 neurones, qui semble suffisant pour capturer les relations sans ajouter de complexité
inutile.
Abalone : Un modèle simplifié avec 4 neurones, mais il est essentiel de revoir la prétraitement des données
(normalisation ou transformation supplémentaire).
Le phénomène de Vanishing Gradient
Le Vanishing Gradient (gradient qui tend vers 0) se produit lorsque les dérivées des fonctions d'activation
dans les couches cachées deviennent très petites, en particulier dans les réseaux profonds ou avec des
fonctions d'activation comme la sigmoid. Cela empêche les poids des couches proches de l'entrée de
s'adapter correctement.
Dans nos résultats :
Le dataset Abalone, l'erreur reste constante pour toutes les dimensions de la couche cachée. Cela peut
indiquer un problème de vanishing gradient ou une saturation de l'apprentissage, en raison de la
propagation faible des gradients.