C02Lb_ml2 revised

Author: phgrosjean

NEWS.md

@@ -1,6 +1,6 @@
 # BioDataScience3 2023.2.0
 
--   Revision of **C02La_cv**.
+-   Revision of **C02La_cv** and **C02Lb_ml2**.
 
 # BioDataScience3 2023.1.1
 

inst/tutorials/C02La_cv/C02La_cv.Rmd

@@ -288,6 +288,8 @@ quiz(
   )
 ```
 
+Si nous revenons un instant sur l'analyse en composantes principales, nous n'avions observé qu'une séparation très faible des deux variétés de riz. L'analyse discriminante linéaire fait bien mieux. Bien que ces deux méthodes soient fortement apparentées et effectuent un calcul relativement similaire, leurs objectifs sont très différents. L'ACP **"étale" les points** au mieux dans le premier plan PC1 - PC2, alors que l'ADL **sépare les classes** au mieux dans le premier plan LD1 - LD2. Vous pouvez donc utiliser les résultats de votre ACP comme point de départ, mais vous ne pouvez pas conclure que la classification se fera bien ou pas sur cette base pour cette seule analyse.
+
 ## Conclusion
 
 Ce tutoriel vous a permis de découvrir la validation croisée appliquée sur une analyse discriminante linéaire. L'avantage de la validation croisée est de pouvoir utiliser plus de données pour entraîner votre classifieur et également pour son test. Il n'est pas nécessaire de séparer les groupes à la main et de calculer *k* fois les performances avant de sommer les *k* matrices de confusion en une seule. La fonction `cvpredict()` se charge de faire tout cela pour vous automatiquement.

inst/tutorials/C02Lb_ml2/C02Lb_ml2.Rmd.inactivated_torework renamed to inst/tutorials/C02Lb_ml2/C02Lb_ml2.Rmd

@@ -12,22 +12,17 @@ allow_skip: true
 runtime: shiny_prerendered
 ---
 
-<!--# Remplacer cela par un autre jeu de données car classer grains de riz, puis des semences de potiron ru base d'analyse d'image, les étudiants vont penser que la classification supervisée ne sert qu'à cela, alors qu'il y a tellement d'autres applications possibles en biologie -->
-
 ```{r setup, include=FALSE}
 BioDataScience3::learnr_setup()
 SciViews::R("ml")
 
-# Import dataset ----
+# Import dataset
 pumpkins <- read("pumpkins", package = "BioDataScience3")
 
-library(rsample)
-set.seed(101121) # Générateur de nombres pseudo-aléatoires
+set.seed(101121)
 pumpkins_split <- initial_split(pumpkins, prop = 0.8)
 pumpkins_split
-# training set
 pumpkins_train <- training(pumpkins_split)
-# test set
 pumpkins_test <- testing(pumpkins_split)
 
 # Classifieurs
@@ -39,7 +34,7 @@ pumpkins_part <- mlRpart(data = pumpkins_train, class ~ .)
 ## Forêt aléatoire
 pumpkins_rf <- mlRforest(data = pumpkins_train, class ~ ., ntree = 100)
 
-# Matrice de confusion
+# Matrices de confusion
 ## K plus proches voisins
 predict(pumpkins_knn, pumpkins_test) |> confusion(pumpkins_test$class) |> summary() ->
   conf_knn
@@ -65,42 +60,42 @@ BioDataScience3::learnr_server(input, output, session)
 
 Ce tutoriel a pour objectif de vous permettre de découvrir de nouveaux algorithmes de classifications supervisées : la méthode des k plus proches voisins, la méthode par arbres de partitionnement et celle dite de la forêt aléatoire.
 
-Ces trois méthodes vont s'ajouter à l'analyse discriminante linéaire que vous avez découverte dans le premier module du cours de SDD III. Toutes ces méthodes font partie de votre boite à outils de la classification supervisée. Concrètement, vous utiliserez la méthode la plus judicieuse en fonction du contexte. Il est même conseillé de les tester et de les comparer afin de conserver le classifieur le plus efficace après cette étude comparative.
+Toutes ces méthodes font partie de votre boite à outils pour la classification supervisée à côté de l'analyse discriminante linéaire et de la quantification vectorielle, ainsi que d'autres techniques encore que vous découvrirez dans le module 3 du cours. Concrètement, vous utiliserez la méthode la plus judicieuse en fonction du contexte. Il est même conseillé d'en tester plusieurs et de les comparer pour ensuite conserver le classifieur le plus efficace après cette étude comparative.
 
-Pour l'ADL, vous avez employé la fonction `mlLda()`. Voici les fonctions du package {mlearning} que vous utiliserez ici :
+Pour l'ADL, vous avez utilisé la fonction `mlLda()`. Voici les fonctions du package {mlearning} que vous utiliserez ici :
 
-| **Méthode**                    | **Fonction**                   |
-|--------------------------------|--------------------------------|
-| Analyse discriminante linéaire | `mlLda(data, formula,...)`     |
-| K plus proches voisins         | `mlKnn(data, formula,...)`     |
-| Partitionnement récursif       | `mlRpart(data, formula,...)`   |
-| Foret aléatoire                | `mlRforest(data, formula,...)` |
+| **Méthode**                    | **Fonction**                          |
+|--------------------------------|---------------------------------------|
+| Analyse discriminante linéaire | `mlLda(data = <df>, formula,...)`     |
+| K plus proches voisins         | `mlKnn(data = <df>, formula,...)`     |
+| Partitionnement récursif       | `mlRpart(data = <df>, formula,...)`   |
+| Foret aléatoire                | `mlRforest(data = <df>, formula,...)` |
 
-Le package {mlearning} permet d'utiliser une interface similaire et simplifiée pour chaque méthode. Il fait partie du dialecte `SciViews::R` et est chargé en spécifiant que lea section relative au "machine learning" doit être également chargée à l'aide de `SciViews::R("ml")`
+Le package {mlearning} permet d'utiliser une interface similaire et simplifiée pour chaque méthode. Il fait partie du dialecte `SciViews::R` et est chargé en spécifiant que la section relative au "machine learning" doit être également chargée à l'aide de `SciViews::R("ml")`
 
-## Explorer les données
+## Exploration des données
 
-Les données employées dans ce tutoriel proviennent de l'article ["the use of machine learning methods in classification of pumpkin seeds (Cucurbita pepo L.)"](https://doi.org/10.1007/s10722-021-01226-0). N'hésitez pas à consulter cet article pour en apprendre davantage sur ces données.
+Les données employées dans ce tutoriel proviennent de l'article ["the use of machine learning methods in classification of pumpkin seeds (Cucurbita pepo L.)"](https://doi.org/10.1007/s10722-021-01226-0). N'hésitez pas à consulter cet article pour en apprendre davantage sur ces données. Nous avons choisi un jeu de données très similaire à celui sur le classement de grains de riz utilisé dans le learnr précédent consacré à la validation croisée pour que vous familiarisiez plus rapidement avec ces données et que vous concentriez votre énergie sur la comparaison des classifieurs. N'en concluez pas pour autant que la classification supervisée ne sert *que* à classer des objets sur base d'images numériques. Les cas d'utilisation en biologie et en sciences biomédicales sont infiniment plus larges, bien entendu.
 
 ```{r, echo=TRUE}
 pumpkins <- read("pumpkins", package = "BioDataScience3")
 ```
 
-Ce tableau de données traite de la différenciation de deux variétés de graines de courge. Il comprend `r nrow(pumpkins)` observations et `r ncol(pumpkins)` variables. Les douze premières variables sont des attributs morphologiques obtenus par analyse d'image et la dernière colonne correspond à la classe. Cette variable facteur est à deux niveaux.
+Ce jeu de données reprend des mesures réalisées sur des graines de deux variétés de courge. Il comprend `r nrow(pumpkins)` observations et `r ncol(pumpkins)` variables. Les douze premières variables sont des attributs morphométriques obtenus par analyse d'image et la dernière colonne `class` correspond à la classe. Cette variable facteur est à deux niveaux.
 
 ```{r}
 skimr::skim(pumpkins)
 ```
 
-C'est à vous d'explorer ce tableau. Vous avez la possibilité de réaliser tous les analyses et graphiques que vous désirez.
+Observez attentivement ces tableaux descriptifs des données. Vous avez la possibilité de réaliser tous les analyses et les graphiques que vous désirez dans la zone ci-dessous pour mieux comprendre les données mises à disposition.
 
 ```{r explo_noscore, exercise=TRUE}
 
 ```
 
-## Préparer le set d'apprentissage et le test
+## Préparation des sets d'apprentissage et de test
 
-Réalisez le set d'apprentissage et le set de test. 80% des observations vont servir à entrainer le classifieur et 20% pour évaluer le classifieur. Le tableau de données se nomme `pumpkins`. Utilisez les fonctions dédiées à la création des sets d'apprentissage et de test `initial_spit()`, `training()`, `testing()`.
+Réalisez le set d'apprentissage et le set de test. 80% des observations vont servir à entraîner le classifieur et 20% seront réservés pour en évaluer les performances. Le jeu de données de départ se nomme `pumpkins`. Utilisez les fonctions de création des sets d'apprentissage et de test `initial_spit()`, `training()`, `testing()`.
 
 ```{r split_h2, exercise=TRUE}
 set.seed(101121) # Générateur de nombres pseudo-aléatoires
@@ -125,6 +120,7 @@ pumpkins_test <- ___(___)
 ```
 
 ```{r split_h2-solution}
+## Solution ##
 set.seed(101121) # Générateur de nombres pseudo-aléatoires
 pumpkins_split <- initial_split(pumpkins, prop = 0.8)
 pumpkins_split
@@ -135,12 +131,12 @@ pumpkins_test <- testing(pumpkins_split)
 ```
 
 ```{r split_h2-check}
-grade_code("La création d'un set d'apprentissage et d'un set de test n'a plus de secret pour vous.")
+grade_code("La création d'un set d'apprentissage et d'un set de test avec ces trois fonctions est facile. L'argument `strata=` de ìnitial_split()` est intéressant pour s'assurer d'avoir les mêmes proportions des différentes classes dans les deux sets mais n'est pas indispensable, et n'est pas utilisé ici.")
 ```
 
-## Entrainement des classifieurs
+## Entraînement des classifieurs
 
-Créez trois classifieurs. Le premier doit employer la méthode des k plus proches voisins avec 15 individus proches considérés (`k.nn=`). Le second sera basé sur le partitionnement récursif. Le troisième doit utiliser la forêt aléatoire avec un nombre d'arbres limité à 100 (`ntree=`). Utilisez le set d'apprentissage préparé à l'étape précédente ainsi qu'une formule condensée.
+Créez trois classifieurs. Le premier doit utiliser la méthode des k plus proches voisins avec 15 individus proches considérés (`k.nn=`). Le second sera basé sur le partitionnement récursif. Le troisième doit utiliser la forêt aléatoire avec un nombre d'arbres limité à 100 (`ntree=`). Utilisez le set d'apprentissage préparé à l'étape précédente ainsi qu'une formule condensée.
 
 ```{r ml_h2, exercise=TRUE}
 set.seed(3265)
@@ -165,6 +161,7 @@ pumpkins_rf <- ml___(data = ___, ___~___, ___ = ___)
 ```
 
 ```{r ml_h2-solution}
+## Solution ##
 set.seed(3265)
 # K plus proches voisins
 pumpkins_knn <- mlKnn(data = pumpkins_train, class ~ ., k.nn = 15)
@@ -178,7 +175,7 @@ pumpkins_rf <- mlRforest(data = pumpkins_train, class ~ ., ntree = 100)
 grade_code("Vous avez maintenant les trois classifieurs avec les arguments demandés. Passons à l'analyse des performances de ces classifieurs.")
 ```
 
-## Évaluation des perfomances des classifieurs
+## Évaluation des performances des classifieurs
 
 Évaluez les trois classifieurs `pumpkins_knn`, `pumpkins_part` et `pumpkins_rf`. Choisissez bien le tableau de données à employer entre `pumpkins`, `pumpkins_train` et `pumpkins_test` pour la prédiction et l'élaboration de la matrice de confusion. Résumez cette dernière pour obtenir les différentes métriques. Utilisez l'opérateur de pipe natif de R `|>` pour organiser votre code.
 
@@ -203,6 +200,7 @@ predict(___, ____) |> confusion(___$___) |> summary()
 ```
 
 ```{r predict_h2-solution}
+## Solution ##
 # K plus proches voisins
 predict(pumpkins_knn, pumpkins_test) |> confusion(pumpkins_test$class) |> summary()
 # Partitionnement récursif
@@ -212,37 +210,47 @@ predict(pumpkins_rf, pumpkins_test) |> confusion(pumpkins_test$class) |> summary
 ```
 
 ```{r predict_h2-check}
-grade_code("Vous avez calculé les métriques des trois modèles. Choisissez la ou les métriques qui sont les plus pertinentes dans le contexte et comparez vos trois classifieurs afin de décider lequel garder.")
+grade_code("Vous avez calculé les métriques pour les trois classifieurs. Choisissez la ou les métriques qui sont les plus pertinentes dans le contexte et comparez vos trois classifieurs afin de décider lequel garder.")
 ```
 
 ```{r qu_algo}
 quiz(
-  question("Quel est le taux de vrais positifs pour le groupe des Cercevelik obtenu via le classifieur utilisant les k plus proches voisins ?",
+  question("Quel est le taux de vrais positifs pour le groupe des `Cercevelik` obtenu via le classifieur utilisant les k plus proches voisins ?",
     answer(sprintf("%.4f", conf_knn["Cercevelik",]$Recall), correct = TRUE),
     answer(sprintf("%.4f", conf_knn["Cercevelik",]$Precision)),
     answer(sprintf("%.4f", conf_knn["Cercevelik",]$Fscore)),
     answer(sprintf("%.4f", conf_knn["Cercevelik",]$FDR)),
     allow_retry = TRUE, 
     submit_button = "Soumettre une réponse",
     try_again_button = "Resoumettre une réponse",
-    incorrect = "Mauvaise réponse. Recommencez et analysez plus finement les métriques associés à ce classifieur.",
+    incorrect = "Mauvaise réponse. Recommencez et analysez plus finement les métriques calculées pour ce classifieur.",
     correct = "Le rappel est équivalent au taux de vrais positifs."),
-  question("Quel est la spécificité pour le groupe des Urgup Sivrisi obtenu via le classifieur utilisant le partitionnement récursif ?",
+  question("Quel est la spécificité pour le groupe des `Urgup Sivrisi` obtenu via le classifieur utilisant le partitionnement récursif ?",
     answer(sprintf("%.4f", conf_part["Urgup Sivrisi",]$Specificity), correct = TRUE),
     answer(sprintf("%.4f", conf_part["Urgup Sivrisi",]$Precision)),
     answer(sprintf("%.4f", conf_part["Urgup Sivrisi",]$Fscore)),
     answer(sprintf("%.4f", conf_part["Urgup Sivrisi",]$FDR)),
     allow_retry = TRUE, 
     submit_button = "Soumettre une réponse",
     try_again_button = "Resoumettre une réponse",
-    incorrect = "Mauvaise réponse. Recommencez et analysez plus finement les métriques associés à ce classifieur.",
+    incorrect = "Mauvaise réponse. Recommencez et analysez plus finement les métriques calculées pour ce classifieur.",
     correct = "C'est bien cela. Examinez les performances des trois classifieurs un moment pour les comparer par vous-mêmes et pour déterminer lequel est le plus efficace ici. Quelle métrique choisissez-vous pour cela ?")
   )
 ```
 
+**Avant de cliquer sur "Next Topic", examinez ces résultats, comparez les trois classifieurs, et décidez en fonction de la métrique que vous jugez la plus appropriée quel est le meilleur des trois ici...** Réponse dans la section suivante.
+
 ## Conclusion
 
-Vous venez de découvrir trois nouveaux algorithmes de classifications supervisées. Votre boite à outils s'étoffe de module en module.
+**Choix du meilleur classifieur :**
+
+-   La métrique à utiliser ici est le score F car nous souhaitons obtenir un bon compromis entre rappel et précision et nous n'avons pas de classe cible. La proportion d'items dans les deux classes est très proche et nous n'avons donc pas de difficultés liées à une répartition qui serait très mal balancée.
+
+-   La forêt aléatoire (classifieur #3) semble donner les meilleurs résultats, mais de très peu sur le partitionnement récursif (classifieur #2). Le gain selon le score F n'est toutefois que de 1% environ pour les deux classes entre ces classifieurs. C'est faible et de plus, la forêt aléatoire donne des résultats qui fluctuent d'un entraînement à l'autre (hors fixation du `set.seed()`). Il faudrait recommencer plusieurs fois ce classifieur pour avoir une idée de l'amplitude de cette variation et la comparer aux résultats du classifieur #2 avant de tirer une conclusion définitive.
+
+-   Même si la forêt aléatoire donne un résultat sensiblement meilleur que le partitionnement récursif, ce dernier est bien plus rapide à calculer. Il se pourrait que, dans une application de tri de pépins en temps réel (par exemple, un tapis roulant amène les graines une à une devant une caméra et le logiciel qui gère le robot doit donner une réponse instantanée pour animer ensuite un bras de tri de ces pépins), le temps de calcul soit un critère prépondérant. Dans ce cas peut être que le classifieur #2 est le meilleur dans un tel contexte.
+
+Vous venez de découvrir trois nouveaux algorithmes de classification supervisée. Votre boite à outils s'étoffe de module en module.
 
 ```{r comm_noscore, echo=FALSE}
 question_text(