msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
ML-For-Beginners/translations/fr/4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb

650 lines
27 KiB
Raw Permalink Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "lesson_12-R.ipynb",
"provenance": [],
"collapsed_sections": []
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "fab50046ca413a38939d579f8432274f",
"translation_date": "2025-09-04T02:33:50+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
"language_code": "fr"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "jsFutf_ygqSx"
},
"source": [
"# Construire un modèle de classification : Délicieuses cuisines asiatiques et indiennes\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HD54bEefgtNO"
},
"source": [
"## Classificateurs de cuisine 2\n",
"\n",
"Dans cette deuxième leçon sur la classification, nous allons explorer `davantage de méthodes` pour classifier les données catégorielles. Nous examinerons également les implications du choix d'un classificateur plutôt qu'un autre.\n",
"\n",
"### [**Quiz avant la leçon**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)\n",
"\n",
"### **Prérequis**\n",
"\n",
"Nous supposons que vous avez terminé les leçons précédentes, car nous allons reprendre certains concepts abordés auparavant.\n",
"\n",
"Pour cette leçon, nous aurons besoin des packages suivants :\n",
"\n",
"- `tidyverse` : Le [tidyverse](https://www.tidyverse.org/) est une [collection de packages R](https://www.tidyverse.org/packages) conçue pour rendre la science des données plus rapide, plus facile et plus agréable !\n",
"\n",
"- `tidymodels` : Le framework [tidymodels](https://www.tidymodels.org/) est une [collection de packages](https://www.tidymodels.org/packages/) dédiée à la modélisation et à l'apprentissage automatique.\n",
"\n",
"- `themis` : Le package [themis](https://themis.tidymodels.org/) fournit des étapes supplémentaires pour traiter les données déséquilibrées.\n",
"\n",
"Vous pouvez les installer avec la commande suivante :\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"kernlab\", \"themis\", \"ranger\", \"xgboost\", \"kknn\"))`\n",
"\n",
"Sinon, le script ci-dessous vérifie si vous avez les packages nécessaires pour compléter ce module et les installe pour vous s'ils sont manquants.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "vZ57IuUxgyQt"
},
"source": [
"suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load(tidyverse, tidymodels, themis, kernlab, ranger, xgboost, kknn)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "z22M-pj4g07x"
},
"source": [
"## **1. Une carte de classification**\n",
"\n",
"Dans notre [leçon précédente](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1), nous avons tenté de répondre à la question : comment choisir entre plusieurs modèles ? En grande partie, cela dépend des caractéristiques des données et du type de problème que nous voulons résoudre (par exemple, classification ou régression ?)\n",
"\n",
"Auparavant, nous avons appris les différentes options disponibles pour classifier des données en utilisant l'aide-mémoire de Microsoft. Le framework de Machine Learning en Python, Scikit-learn, propose un aide-mémoire similaire mais plus détaillé, qui peut vous aider à affiner davantage vos estimateurs (un autre terme pour désigner les classificateurs) :\n",
"\n",
"<p >\n",
" <img src=\"../../images/map.png\"\n",
" width=\"700\"/>\n",
" <figcaption></figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "u1i3xRIVg7vG"
},
"source": [
"> Conseil : [consultez cette carte en ligne](https://scikit-learn.org/stable/tutorial/machine_learning_map/) et cliquez sur les chemins pour lire la documentation. \n",
"> \n",
"> Le [site de référence Tidymodels](https://www.tidymodels.org/find/parsnip/#models) propose également une excellente documentation sur les différents types de modèles.\n",
"\n",
"### **Le plan** 🗺️\n",
"\n",
"Cette carte est très utile une fois que vous comprenez bien vos données, car vous pouvez \"suivre\" ses chemins pour arriver à une décision :\n",
"\n",
"- Nous avons \\>50 échantillons\n",
"\n",
"- Nous voulons prédire une catégorie\n",
"\n",
"- Nous avons des données étiquetées\n",
"\n",
"- Nous avons moins de 100K échantillons\n",
"\n",
"- ✨ Nous pouvons choisir un Linear SVC\n",
"\n",
"- Si cela ne fonctionne pas, étant donné que nous avons des données numériques :\n",
"\n",
" - Nous pouvons essayer un ✨ KNeighbors Classifier\n",
"\n",
" - Si cela ne fonctionne pas, essayez ✨ SVC et ✨ Ensemble Classifiers\n",
"\n",
"C'est un chemin très utile à suivre. Maintenant, passons directement à l'action en utilisant le framework de modélisation [tidymodels](https://www.tidymodels.org/) : une collection cohérente et flexible de packages R développée pour encourager de bonnes pratiques statistiques 😊.\n",
"\n",
"## 2. Diviser les données et gérer un ensemble de données déséquilibré.\n",
"\n",
"Dans nos leçons précédentes, nous avons appris qu'il existait un ensemble d'ingrédients communs à travers nos cuisines. De plus, il y avait une répartition assez inégale du nombre de cuisines.\n",
"\n",
"Nous allons gérer cela en :\n",
"\n",
"- Supprimant les ingrédients les plus courants qui créent de la confusion entre des cuisines distinctes, en utilisant `dplyr::select()`.\n",
"\n",
"- Utilisant une `recipe` qui prétraite les données pour les préparer à la modélisation en appliquant un algorithme de `sur-échantillonnage`.\n",
"\n",
"Nous avons déjà vu cela dans la leçon précédente, donc cela devrait être un jeu d'enfant 🥳 !\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "6tj_rN00hClA"
},
"source": [
"# Load the core Tidyverse and Tidymodels packages\n",
"library(tidyverse)\n",
"library(tidymodels)\n",
"\n",
"# Load the original cuisines data\n",
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/4-Classification/data/cuisines.csv\")\n",
"\n",
"# Drop id column, rice, garlic and ginger from our original data set\n",
"df_select <- df %>% \n",
" select(-c(1, rice, garlic, ginger)) %>%\n",
" # Encode cuisine column as categorical\n",
" mutate(cuisine = factor(cuisine))\n",
"\n",
"\n",
"# Create data split specification\n",
"set.seed(2056)\n",
"cuisines_split <- initial_split(data = df_select,\n",
" strata = cuisine,\n",
" prop = 0.7)\n",
"\n",
"# Extract the data in each split\n",
"cuisines_train <- training(cuisines_split)\n",
"cuisines_test <- testing(cuisines_split)\n",
"\n",
"# Display distribution of cuisines in the training set\n",
"cuisines_train %>% \n",
" count(cuisine) %>% \n",
" arrange(desc(n))"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "zFin5yw3hHb1"
},
"source": [
"### Gérer les données déséquilibrées\n",
"\n",
"Les données déséquilibrées ont souvent des effets négatifs sur les performances du modèle. De nombreux modèles fonctionnent mieux lorsque le nombre d'observations est équilibré et, par conséquent, ont tendance à rencontrer des difficultés avec des données non équilibrées.\n",
"\n",
"Il existe principalement deux façons de traiter les ensembles de données déséquilibrés :\n",
"\n",
"- ajouter des observations à la classe minoritaire : `Sur-échantillonnage`, par exemple en utilisant un algorithme SMOTE qui génère de manière synthétique de nouveaux exemples de la classe minoritaire en utilisant les plus proches voisins de ces cas.\n",
"\n",
"- supprimer des observations de la classe majoritaire : `Sous-échantillonnage`\n",
"\n",
"Dans notre leçon précédente, nous avons démontré comment traiter les ensembles de données déséquilibrés en utilisant une `recette`. Une recette peut être considérée comme un plan décrivant les étapes à appliquer à un ensemble de données pour le préparer à l'analyse. Dans notre cas, nous souhaitons obtenir une distribution égale du nombre de nos cuisines pour notre `ensemble d'entraînement`. Allons-y directement.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "cRzTnHolhLWd"
},
"source": [
"# Load themis package for dealing with imbalanced data\n",
"library(themis)\n",
"\n",
"# Create a recipe for preprocessing training data\n",
"cuisines_recipe <- recipe(cuisine ~ ., data = cuisines_train) %>%\n",
" step_smote(cuisine) \n",
"\n",
"# Print recipe\n",
"cuisines_recipe"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "KxOQ2ORhhO81"
},
"source": [
"Nous sommes prêts à entraîner des modèles 👩‍💻👨‍💻 !\n",
"\n",
"## 3. Au-delà des modèles de régression multinomiale\n",
"\n",
"Dans notre leçon précédente, nous avons étudié les modèles de régression multinomiale. Explorons maintenant des modèles plus flexibles pour la classification.\n",
"\n",
"### Machines à vecteurs de support\n",
"\n",
"Dans le contexte de la classification, les `Machines à vecteurs de support` sont une technique d'apprentissage automatique qui cherche à trouver un *hyperplan* qui sépare \"au mieux\" les classes. Prenons un exemple simple :\n",
"\n",
"<p >\n",
" <img src=\"../../images/svm.png\"\n",
" width=\"300\"/>\n",
" <figcaption>https://commons.wikimedia.org/w/index.php?curid=22877598</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C4Wsd0vZhXYu"
},
"source": [
"H1~ ne sépare pas les classes. H2~ les sépare, mais seulement avec une petite marge. H3~ les sépare avec la marge maximale.\n",
"\n",
"#### Classificateur Linéaire à Vecteurs de Support\n",
"\n",
"Le clustering par vecteurs de support (SVC) est une branche de la famille des machines à vecteurs de support, une technique d'apprentissage automatique. Dans le SVC, l'hyperplan est choisi pour séparer correctement `la plupart` des observations d'entraînement, mais `peut mal classer` quelques observations. En permettant à certains points d'être du mauvais côté, le SVM devient plus robuste face aux valeurs aberrantes, ce qui améliore la généralisation aux nouvelles données. Le paramètre qui régule cette violation est appelé `cost`, avec une valeur par défaut de 1 (voir `help(\"svm_poly\")`).\n",
"\n",
"Créons un SVC linéaire en définissant `degree = 1` dans un modèle SVM polynomial.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "vJpp6nuChlBz"
},
"source": [
"# Make a linear SVC specification\n",
"svc_linear_spec <- svm_poly(degree = 1) %>% \n",
" set_engine(\"kernlab\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle specification and recipe into a worklow\n",
"svc_linear_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(svc_linear_spec)\n",
"\n",
"# Print out workflow\n",
"svc_linear_wf"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "rDs8cWNkhoqu"
},
"source": [
"Maintenant que nous avons intégré les étapes de prétraitement et la spécification du modèle dans un *workflow*, nous pouvons passer à l'entraînement du SVC linéaire et évaluer les résultats en même temps. Pour les métriques de performance, créons un ensemble de métriques qui évaluera : `accuracy`, `sensitivity`, `Positive Predicted Value` et `F Measure`.\n",
"\n",
"> `augment()` ajoutera une ou plusieurs colonnes pour les prédictions aux données fournies.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "81wiqcwuhrnq"
},
"source": [
"# Train a linear SVC model\n",
"svc_linear_fit <- svc_linear_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"# Create a metric set\n",
"eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"svc_linear_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "0UFQvHf-huo3"
},
"source": [
"#### Machine à Vecteurs de Support\n",
"\n",
"La machine à vecteurs de support (SVM) est une extension du classificateur à vecteurs de support afin de gérer une frontière non linéaire entre les classes. En substance, les SVM utilisent l’*astuce du noyau* pour agrandir l’espace des caractéristiques et s’adapter aux relations non linéaires entre les classes. Une fonction noyau populaire et extrêmement flexible utilisée par les SVM est la *fonction de base radiale.* Voyons comment elle se comporte avec nos données.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "-KX4S8mzhzmp"
},
"source": [
"set.seed(2056)\n",
"\n",
"# Make an RBF SVM specification\n",
"svm_rbf_spec <- svm_rbf() %>% \n",
" set_engine(\"kernlab\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle specification and recipe into a worklow\n",
"svm_rbf_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(svm_rbf_spec)\n",
"\n",
"\n",
"# Train an RBF model\n",
"svm_rbf_fit <- svm_rbf_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"svm_rbf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "QBFSa7WSh4HQ"
},
"source": [
"Beaucoup mieux 🤩 !\n",
"\n",
"> ✅ Veuillez consulter :\n",
">\n",
"> - [*Support Vector Machines*](https://bradleyboehmke.github.io/HOML/svm.html), Hands-on Machine Learning avec R\n",
">\n",
"> - [*Support Vector Machines*](https://www.statlearning.com/), An Introduction to Statistical Learning with Applications in R\n",
">\n",
"> pour en savoir plus.\n",
"\n",
"### Classificateurs des plus proches voisins\n",
"\n",
"Le *K*-nearest neighbor (KNN) est un algorithme dans lequel chaque observation est prédite en fonction de sa *similarité* avec d'autres observations.\n",
"\n",
"Essayons d'en ajuster un à nos données.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "k4BxxBcdh9Ka"
},
"source": [
"# Make a KNN specification\n",
"knn_spec <- nearest_neighbor() %>% \n",
" set_engine(\"kknn\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"knn_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(knn_spec)\n",
"\n",
"# Train a boosted tree model\n",
"knn_wf_fit <- knn_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"knn_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "HaegQseriAcj"
},
"source": [
"Il semble que ce modèle ne donne pas de très bons résultats. Modifier les arguments du modèle (voir `help(\"nearest_neighbor\")`) pourrait probablement améliorer ses performances. Assurez-vous d'essayer.\n",
"\n",
"> ✅ Veuillez consulter :\n",
">\n",
"> - [Hands-on Machine Learning with R](https://bradleyboehmke.github.io/HOML/)\n",
">\n",
"> - [An Introduction to Statistical Learning with Applications in R](https://www.statlearning.com/)\n",
">\n",
"> pour en savoir plus sur les classificateurs *K*-Nearest Neighbors.\n",
"\n",
"### Classificateurs par ensemble\n",
"\n",
"Les algorithmes d'ensemble fonctionnent en combinant plusieurs estimateurs de base pour produire un modèle optimal, soit en :\n",
"\n",
"`bagging` : appliquant une *fonction de moyenne* à une collection de modèles de base\n",
"\n",
"`boosting` : construisant une séquence de modèles qui s'appuient les uns sur les autres pour améliorer les performances prédictives.\n",
"\n",
"Commençons par essayer un modèle de Forêt Aléatoire, qui construit une grande collection d'arbres de décision, puis applique une fonction de moyenne pour obtenir un meilleur modèle global.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "49DPoVs6iK1M"
},
"source": [
"# Make a random forest specification\n",
"rf_spec <- rand_forest() %>% \n",
" set_engine(\"ranger\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"rf_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(rf_spec)\n",
"\n",
"# Train a random forest model\n",
"rf_wf_fit <- rf_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"rf_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "RGVYwC_aiUWc"
},
"source": [
"Bon travail 👏 !\n",
"\n",
"Essayons également un modèle Boosted Tree.\n",
"\n",
"Boosted Tree définit une méthode d'ensemble qui crée une série d'arbres de décision séquentiels où chaque arbre dépend des résultats des arbres précédents dans le but de réduire progressivement l'erreur. Il se concentre sur les poids des éléments mal classés et ajuste l'ajustement pour le prochain classificateur afin de corriger.\n",
"\n",
"Il existe différentes façons d'ajuster ce modèle (voir `help(\"boost_tree\")`). Dans cet exemple, nous ajusterons les Boosted Trees via le moteur `xgboost`.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Py1YWo-micWs"
},
"source": [
"# Make a boosted tree specification\n",
"boost_spec <- boost_tree(trees = 200) %>% \n",
" set_engine(\"xgboost\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"boost_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(boost_spec)\n",
"\n",
"# Train a boosted tree model\n",
"boost_wf_fit <- boost_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"boost_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "zNQnbuejigZM"
},
"source": [
"> ✅ Veuillez consulter :\n",
">\n",
"> - [Machine Learning for Social Scientists](https://cimentadaj.github.io/ml_socsci/tree-based-methods.html#random-forests)\n",
">\n",
"> - [Hands-on Machine Learning with R](https://bradleyboehmke.github.io/HOML/)\n",
">\n",
"> - [An Introduction to Statistical Learning with Applications in R](https://www.statlearning.com/)\n",
">\n",
"> - <https://algotech.netlify.app/blog/xgboost/> - Explore le modèle AdaBoost, une bonne alternative à xgboost.\n",
">\n",
"> pour en savoir plus sur les classificateurs ensemblistes.\n",
"\n",
"## 4. Extra - comparer plusieurs modèles\n",
"\n",
"Nous avons ajusté un bon nombre de modèles dans ce laboratoire 🙌. Cela peut devenir fastidieux ou compliqué de créer de nombreux workflows à partir de différents ensembles de préprocesseurs et/ou spécifications de modèles, puis de calculer les métriques de performance une par une.\n",
"\n",
"Voyons si nous pouvons résoudre ce problème en créant une fonction qui ajuste une liste de workflows sur l'ensemble d'entraînement, puis retourne les métriques de performance basées sur l'ensemble de test. Nous allons utiliser `map()` et `map_dfr()` du package [purrr](https://purrr.tidyverse.org/) pour appliquer des fonctions à chaque élément d'une liste.\n",
"\n",
"> Les fonctions [`map()`](https://purrr.tidyverse.org/reference/map.html) vous permettent de remplacer de nombreuses boucles for par un code à la fois plus concis et plus facile à lire. Le meilleur endroit pour apprendre les fonctions [`map()`](https://purrr.tidyverse.org/reference/map.html) est le [chapitre sur l'itération](http://r4ds.had.co.nz/iteration.html) dans R for data science.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Qzb7LyZnimd2"
},
"source": [
"set.seed(2056)\n",
"\n",
"# Create a metric set\n",
"eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
"\n",
"# Define a function that returns performance metrics\n",
"compare_models <- function(workflow_list, train_set, test_set){\n",
" \n",
" suppressWarnings(\n",
" # Fit each model to the train_set\n",
" map(workflow_list, fit, data = train_set) %>% \n",
" # Make predictions on the test set\n",
" map_dfr(augment, new_data = test_set, .id = \"model\") %>%\n",
" # Select desired columns\n",
" select(model, cuisine, .pred_class) %>% \n",
" # Evaluate model performance\n",
" group_by(model) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class) %>% \n",
" ungroup()\n",
" )\n",
" \n",
"} # End of function"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "Fwa712sNisDA"
},
"source": []
},
{
"cell_type": "code",
"metadata": {
"id": "3i4VJOi2iu-a"
},
"source": [
"# Make a list of workflows\n",
"workflow_list <- list(\n",
" \"svc\" = svc_linear_wf,\n",
" \"svm\" = svm_rbf_wf,\n",
" \"knn\" = knn_wf,\n",
" \"random_forest\" = rf_wf,\n",
" \"xgboost\" = boost_wf)\n",
"\n",
"# Call the function\n",
"set.seed(2056)\n",
"perf_metrics <- compare_models(workflow_list = workflow_list, train_set = cuisines_train, test_set = cuisines_test)\n",
"\n",
"# Print out performance metrics\n",
"perf_metrics %>% \n",
" group_by(.metric) %>% \n",
" arrange(desc(.estimate)) %>% \n",
" slice_head(n=7)\n",
"\n",
"# Compare accuracy\n",
"perf_metrics %>% \n",
" filter(.metric == \"accuracy\") %>% \n",
" arrange(desc(.estimate))\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "KuWK_lEli4nW"
},
"source": [
"[**workflowset**](https://workflowsets.tidymodels.org/) permet aux utilisateurs de créer et d'ajuster facilement un grand nombre de modèles, mais il est principalement conçu pour fonctionner avec des techniques de rééchantillonnage telles que la `validation croisée`, une approche que nous n'avons pas encore abordée.\n",
"\n",
"## **🚀Défi**\n",
"\n",
"Chacune de ces techniques possède un grand nombre de paramètres que vous pouvez ajuster, comme par exemple `cost` pour les SVM, `neighbors` pour les KNN, ou `mtry` (Prédicteurs Sélectionnés Aléatoirement) pour les Forêts Aléatoires.\n",
"\n",
"Faites des recherches sur les paramètres par défaut de chacun et réfléchissez à ce que modifier ces paramètres pourrait signifier pour la qualité du modèle.\n",
"\n",
"Pour en savoir plus sur un modèle particulier et ses paramètres, utilisez : `help(\"model\")`, par exemple `help(\"rand_forest\")`.\n",
"\n",
"> En pratique, nous *estimons* généralement les *meilleures valeurs* pour ces paramètres en entraînant de nombreux modèles sur un `jeu de données simulé` et en mesurant les performances de tous ces modèles. Ce processus s'appelle **l'optimisation**.\n",
"\n",
"### [**Quiz après le cours**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)\n",
"\n",
"### **Révision & Étude Personnelle**\n",
"\n",
"Il y a beaucoup de jargon dans ces leçons, alors prenez un moment pour consulter [cette liste](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) de terminologie utile !\n",
"\n",
"#### MERCI À :\n",
"\n",
"[`Allison Horst`](https://twitter.com/allison_horst/) pour avoir créé les illustrations incroyables qui rendent R plus accueillant et engageant. Retrouvez plus d'illustrations dans sa [galerie](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM).\n",
"\n",
"[Cassie Breviu](https://www.twitter.com/cassieview) et [Jen Looper](https://www.twitter.com/jenlooper) pour avoir créé la version originale en Python de ce module ♥️\n",
"\n",
"Bon apprentissage,\n",
"\n",
"[Eric](https://twitter.com/ericntay), Gold Microsoft Learn Student Ambassador.\n",
"\n",
"<p >\n",
" <img src=\"../../images/r_learners_sm.jpeg\"\n",
" width=\"569\"/>\n",
" <figcaption>Illustration par @allison_horst</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**Avertissement** : \nCe document a été traduit à l'aide du service de traduction automatique [Co-op Translator](https://github.com/Azure/co-op-translator). Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.\n"
]
}
]
}
Reference in new issue View Git Blame Copy Permalink