diff --git a/.Rprofile b/.Rprofile new file mode 100644 index 0000000..81b960f --- /dev/null +++ b/.Rprofile @@ -0,0 +1 @@ +source("renv/activate.R") diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..ad94d85 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,36 @@ +on: + workflow_dispatch: + push: + branches: main + +name: Quarto Publish + +jobs: + build-deploy: + runs-on: ubuntu-latest + permissions: + contents: write + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - name: Check out repository + uses: actions/checkout@v3 + + - name: Set up Quarto + uses: quarto-dev/quarto-actions/setup@v2 + with: + # To install LaTeX to build PDF book + tinytex: true + + - name: Setting up R + uses: r-lib/actions/setup-r@v2 + with: + use-public-rspm: true + + - name: Dependencies + uses: r-lib/actions/setup-renv@v2 + + - name: Render and Publish + uses: quarto-dev/quarto-actions/publish@v2 + with: + target: gh-pages diff --git a/.gitignore b/.gitignore index fae8299..e7e2ba8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,39 +1,36 @@ # History files .Rhistory .Rapp.history - # Session Data files .RData - # User-specific files .Ruserdata - # Example code in package build process *-Ex.R - # Output files from R CMD build /*.tar.gz - # Output files from R CMD check /*.Rcheck/ - # RStudio files .Rproj.user/ - # produced vignettes vignettes/*.html vignettes/*.pdf - # OAuth2 token, see https://github.com/hadley/httr/releases/tag/v0.3 .httr-oauth - # knitr and R markdown default cache directories *_cache/ /cache/ - # Temporary files created by R markdown *.utf8.md *.knit.md - # R Environment Variables .Renviron +*.Rproj + +/.quarto/ + +_site/ +libs/ +*_files/ +**/*.quarto_ipynb diff --git a/Bibliographie.bib b/Bibliographie.bib new file mode 100644 index 0000000..f335074 --- /dev/null +++ b/Bibliographie.bib @@ -0,0 +1,33 @@ +@software{Barnier, + author = {Julien Barnier and + Mayeul Kauffmann}, + title = {"Introduction à R et au tydiverse"}, + month = may, + year = 2023, + publisher = {Zenodo}, + version = {v2023-05-02}, + doi = {10.5281/zenodo.6382598}, +} + +@misc{swirldev, + title={Basic R programming}, + author={swirldev}, + year={2022}, + url={https://github.com/swirldev/R_Programming_E}, + Accessed={09/2022}, +} + +@book{wickham2016r, + title={R for data science: import, tidy, transform, visualize, and model data}, + author={Wickham, Hadley and Grolemund, Garrett}, + year={2016}, + url={https://r4ds.had.co.nz/index.html}, + publisher={" O'Reilly Media, Inc."} +} + +@book{phillips2017yarrr, + title={YaRrr! The Pirate’s Guide to R}, + author={Phillips, Nathaniel D}, + year={2018}, + url={https://bookdown.org/ndphillips/YaRrr/} +} diff --git a/BibliographieExercice.bib b/BibliographieExercice.bib new file mode 100644 index 0000000..5132860 --- /dev/null +++ b/BibliographieExercice.bib @@ -0,0 +1,7 @@ +@book{wickham2016r, + title={R for data science: import, tidy, transform, visualize, and model data}, + author={Wickham, Hadley and Grolemund, Garrett}, + year={2016}, + url={https://r4ds.had.co.nz/index.html}, + publisher={" O'Reilly Media, Inc."} +} diff --git a/ECLibre/01Introduction.qmd b/ECLibre/01Introduction.qmd new file mode 100644 index 0000000..130a661 --- /dev/null +++ b/ECLibre/01Introduction.qmd @@ -0,0 +1,549 @@ +--- +title: "Apprendre la Programmation (en R) avec les LLMs" +subtitle: "" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + slide-number: true + incremental: true + smaller: false + scrollable: true + link-external-newwindow: true + output-file: slide-introduction.html + embed-resources: true +lang: fr +--- + +# Introduction + +## Bienvenue ! 🚀 + +**Apprendre la Programmation (en R) avec les LLMs** + + +:::: {.columns} +::: {.column width="33%"} +**🤖 LLM = Votre Assistant** + +LLM : Large Language Model, aussi connu sous le nom d'IA générative + +Ex : ChatGPT, Claude, Mistral, etc. +::: + +::: {.column width="33%"} +**📊 R = Langage Statistique** + +Pour analyser, visualiser, calculer +::: + +::: {.column width="33%"} +**🎯 Objectif = Collaboration** + +Programmer AVEC l'IA générative intelligemment +::: +:::: + +## Sondage 📊 + +**Levez la main si vous avez déjà (Pas de jugement ! 😊)...** + +- Utilisé un LLM (ChatGPT, Claude, etc) ? 🙋‍♀️ +- Demandé leur aide pour un devoir ? 📝 +- Copié-collé une de leur réponse sans la comprendre ? 😅 +- Fait confiance aveuglément à un LLM ? 🤖 +- Payé pour un LLM ? +- Programmé dans n'importe quel langage de programmation ? 💻 + + +# Pourquoi ce cours ? 🎯 + +## Que va-t-on apprendre ? + + + +### Comment utilisez-vous des LLMs ? + + + +::: {.fragment} + +### L'approche ici + +- Poser les BONNES questions +- Vérifier et corriger les erreurs +- Comprendre les réponses +- Utiliser le LLM comme partenaire + +::: + +::: {.fragment} +**Objectif :** Autonomie et esprit critique + +::: + +::: { .notes } +Ici, demander des exemples de ce qu'ils font +::: + +## Démonstration : Prompt + +:::: {.columns} +::: {.column width="50%" .fragment} +### Prompt 1 (Essayez !) + +``` +"Fais-moi des statistiques sur mes données" +``` + +- Problème : Trop vague ! +- Quelles données ? +- Quelles statistiques ? +- Quel format de sortie ? +::: + +::: {.column width="49%" .fragment} +### Prompt 2 + +``` +"J'ai 10 notes d'étudiants : +12, 15, 18, 14, 16, 13, 17, 11, 19, 15. +Calcule la moyenne, médiane et l'écart-type +en R avec des commentaires explicatifs." +``` + +**Résultat :** Code précis et commenté ! +::: +:::: + +::: {.notes} +Proposer aux étudiants de le faire eux-même. +Commencez par le prompt 1, puis les amener au prompt 2 en formalisant un peu le problème. +::: + + +## Objectif du cours + +- Apprendre à utiliser R et Rstudio +- Apprendre à utiliser les principales librairies (aussi appelées paquets) de R pour l'analyse de données et les statistiques (le tidyverse) +- Vous apprendre à utiliser des LLMs pour faire cela + + + +# R et Rstudio ? 📊 + +## R et RStudio : Vos nouveaux outils + +:::: {.columns} + +::: {.column width="50%" .fragment } + +### R = Le Moteur 🚗 + +- Langage de programmation +- Spécialisé en analyse de données +- Dérive d'un langage antérieur appelé S +- Est un [logiciel libre](https://fr.wikipedia.org/wiki/Logiciel_libre) + +::: + +::: {.column width="50%" .fragment } + +### RStudio = L'Interface 🖥️ + +- Environnement convivial +- Facilite l'écriture de code R +- Intègre tout en un endroit +- Comme Word pour l'écriture + +::: + +:::: + +## Exemples concrets d'usage 🌟 + +- 📈 **Analyser un sondage** : "Quel pourcentage préfère le chocolat ?" +- 📊 **Créer des graphiques** : Histogrammes, courbes, diagrammes +- 🧮 **Calculs statistiques** : Moyennes, corrélations, tests +- 🏃 **Données géographiques** : Cartes +- 📋 **Nettoyer des données** : Corriger, organiser, structurer +- 🎯 **Prédictions simples** : "Quelle sera la prochaine tendance ?" + +## Premier aperçu du code R + +```{r moyenne} +#| echo: true +#| eval: true + +# Créer une liste de notes +notes <- c(15, 12, 18, 14, 16, 13, 17) +# Calculer la moyenne +moyenne <- mean(notes) +# Afficher le résultat +print(paste("La moyenne est :", moyenne)) +``` + +**C'est tout ! Pas si compliqué, non ?** 😊 + +# Comment ça marche avec un LLM ? 🤝 + +## Le processus en 4 étapes + +1. 🎯 Formuler une question précise + - Au lieu de "fais-moi des calculs" + - Dire "calcule la moyenne de ces 5 notes : 12, 15, 18, 14, 16" + +2. 🤖 Recevoir et comprendre la réponse + - Le LLM vous donne du code + des explications (si vous lui demandez) + +3. 🧪 Tester et vérifier + - Exécuter le code, voir si ça marche, comprendre pourquoi + +4. ✨ Améliorer si nécessaire + - Corriger les erreurs, adapter à vos besoins + +## Exemple + +Votre demande (à votre LLM préféré) +``` +"J'ai des données de vente par mois : +Janvier : 1500€, Février : 2000€, Mars : 1800€ +Crée un graphique en barres avec R" +``` + +Essayez ! + +## Exemple (réponse possible) + + +```{r vente-code} +#| eval: false +#| echo: true + +# Données de vente +mois <- c("Janvier", "Février", "Mars") +ventes <- c(1500, 2000, 1800) + +# Créer le graphique +barplot(ventes, names.arg = mois, + main = "Ventes par mois", + ylab = "Montant (€)") +``` + +## Le résultat + +```{r vente-graph} +#| echo: true +#| eval: true +#| fig-width: 8 +#| fig-height: 4 + +# Testons le code ! +mois <- c("Janvier", "Février", "Mars") +ventes <- c(1500, 2000, 1800) + +barplot(ventes, names.arg = mois, + main = "Ventes par mois", + ylab = "Montant (€)", + col = "steelblue") +``` + +# Les Erreurs : Vos Amies ! 🐛 + +## Pourquoi on fera des erreurs + +**Principe pédagogique :** Les erreurs sont des occasions d'apprentissage, pas des échecs ! + +- 🎯 **Développer votre esprit critique** +- 🔍 **Apprendre à déboguer** +- 🤖 **Comprendre les limites des LLM** +- 💪 **Gagner en autonomie** +- 🧠 **Mémoriser par l'expérience** + + + +# Organisation du Cours + +## 8 Séances de 3 heures 📅 + +Le cours est structuré en 3 phases progressives sur 8 séances de 3h. + +### Phase 1 : Fondations 🌱 (Séances 1-3) + +**Objectif :** Maîtriser le dialogue avec un LLM et les concepts R de base + +#### Séance 1 : Premiers pas avec R + +::: {.nonincremental} +- Découvrir RStudio et son interface +- Comprendre les concepts de base : objets, types, vecteurs +- Utiliser des fonctions intégrées +- Créer son premier script +- Commencer son journal de bord +::: + +#### Séance 2 : Données et visualisations + +::: {.nonincremental} +- Importer des données réelles (fichiers CSV) +- Explorer des dataframes +- Calculer des statistiques descriptives +- Créer des visualisations simples +- Apprendre à déboguer efficacement +::: + +#### Séance 3 : Automatisation et fonctions + +::: {.nonincremental} +- Utiliser des conditions (`if/else`) +- Créer des boucles (`for`, `while`) +- Écrire vos propres fonctions +- Combiner tous les concepts appris +::: + +### Phase 2 : Application 🚀 (Séances 4-5) + +**Objectif :** Analyser de vraies données en autonomie + +#### Séance 4 : Données tabulaires et graphiques avancés + +::: {.nonincremental} +- Maîtriser les dataframes complexes +- Nettoyage de données (casse, formats, incohérences) +- Visualisations avec ggplot2 +- Créer des fonctions de visualisation réutilisables +::: + +#### Séance 5 : Projet personnel intégré + +::: {.nonincremental} +- Choix et cadrage d'un projet personnel +- Analyse complète de A à Z en autonomie +- Présentation des résultats aux pairs +::: + +### Phase 3 : Expertise ⭐ (Séances 6-8) + +**Objectif :** Devenir autonome et collaborer efficacement + +#### Séance 6 : Organisation et modularité + +::: {.nonincremental} +- Structurer son code en modules +- Découvrir l'écosystème des packages (`dplyr`, `lubridate`) +- Organiser ses fonctions en scripts thématiques +::: + +#### Séance 7 : Automatisation et rapports + +::: {.nonincremental} +- Automatiser des analyses répétitives +- Traiter plusieurs fichiers à la fois +- Créer des rapports reproductibles avec markdown +::: + +#### Séance 8 : Projet collaboratif final + +::: {.nonincremental} +- Travailler en équipe sur un grand dataset +- Code review croisé entre équipes +- Intégrer les bonnes pratiques de développement +- Présentation finale +::: + +## Progression pédagogique + +::: {.incremental} +- **Séances 1-3** → Bases : concepts fondamentaux et autonomie technique +- **Séances 4-5** → Application : projets personnels et analyses complètes +- **Séances 6-8** → Expertise : organisation, automatisation et collaboration +::: + +::: {.fragment} +**À la fin du cours, vous serez capable de :** analyser des données en autonomie, créer vos propres outils, automatiser vos analyses, collaborer sur du code, et utiliser les LLMs comme de véritables partenaires de travail. +::: + +## Structure d'une séance type + +:::: {.columns} +::: {.column width="33%"} +### 🎭 Présentation +**30-60 min** + +- Concepts du jour +- Démonstrations en direct +- Exemples concrets +::: + +::: {.column width="33%"} +### 💻 Pratique +**90-120 min** + +- Exercices sur machine +- Aide individuelle +- Déboguing collectif +::: + +::: {.column width="33%"} +### 🤝 Partage +**30 min** + +- Retours d'expérience +- Solutions créatives +::: +:::: + +# Évaluation 📊 + +## Une évaluation bienveillante + +**Cours noté** : L'objectif est d'évaluer votre progression, pas de vous piéger ! + +### Composition de la note + +Votre note finale est répartie en 3 composantes : + +```{r notes} +#| echo: false +#| eval: true +#| fig-width: 8 +#| fig-height: 5 +#| fig-align: "center" + +# Création d'un graphique des évaluations +library(ggplot2) +evaluations <- data.frame( + Type = c("Journal de bord", "Mini-projets", "Participation"), + Poids = c(40, 40, 20), + Description = c("Apprentissage", "Rendus", "En classe") +) + +ggplot(evaluations, aes(x = reorder(Type, -Poids), y = Poids, fill = Type)) + + geom_bar(stat = "identity") + + geom_text(aes(label = paste(Poids, "%")), vjust = -0.5, size = 6) + + labs(y = "Pourcentage de la note", x = "") + + theme_minimal() + + theme(legend.position = "none", + text = element_text(size = 14), + axis.text.x = element_text(size = 12)) +``` + +## 📓 Journal de bord (40%) {.smaller} + +Document votre apprentissage tout au long du semestre. + +**Pour chaque séance, notez :** + +::: {.nonincremental} +- Les **prompts** utilisés avec les LLMs (copier-coller exact) +- Les **réponses** obtenues (copier-coller, pas de captures d'écran) +- Votre **compréhension** avec vos propres mots +- Les **difficultés** et erreurs rencontrées +- Les **solutions** trouvées +- Le **code** produit et commenté +::: + +::: {.fragment} +::: {.callout-tip} +## Soyez honnête ! +Documentez vos échecs comme vos réussites. C'est votre progression qui compte. +::: +::: + +## 🎯 Mini-projets (40%) {.smaller} + +Rendus de fin de séance à soumettre sur Moodle. + +::: {.nonincremental} +- **Séance 1** : Script commenté avec analyse de données simple +- **Séance 2** : Analyse de données INSEE avec visualisations +- **Séance 3** : Fonctions personnalisées pour analyse de températures +::: + +::: {.fragment} +**Critères :** Code fonctionnel, commenté, résout le problème posé +::: + +## 👥 Participation (20%) {.smaller} + +Votre engagement pendant les séances. + +::: {.incremental} +- **Présence active** : Vous travaillez sur les exercices +- **Entraide** : Vous aidez vos camarades ou demandez de l'aide +- **Déboguing collectif** : Vous partagez vos solutions +- **Questions** : Vous posez des questions pertinentes +::: + +::: {.fragment} +::: {.callout-note} +## Pas de stress ! +La participation, ce n'est pas parler beaucoup, c'est être engagé dans votre apprentissage. +::: +::: + + +# Questions & Discussion 💬 + +## Vos interrogations + +**Quelles sont vos questions ?** 🤔 + +- 🤖 Sur l'utilisation des LLM ? +- 📊 Sur le langage R ? +- 📅 Sur l'organisation du cours ? +- 📝 Sur l'évaluation ? + +**Pas de question bête !** Nous sommes tous là pour apprendre ensemble 😊 + +# Prochaines Étapes 🎯 + +## Maintenant + +1. 📥 **Installer R et RStudio** (tutoriel fourni, si sur votre machine, démarrez Rstudio sinon) +2. 🔐 **Créer un compte LLM** (facultatif) +4. 🧪 **Essayer un premier prompt** simple + +## Merci ! + +*N'oubliez pas : l'erreur est votre amie !* 😊 + +:::: {.columns} +::: {.column width="33%"} +**📚 Apprenez** +::: + +::: {.column width="33%"} +**🔍 Explorez** +::: + +::: {.column width="33%"} +**🎉 Réussissez** +::: +:::: + +## Ressources disponibles + +### 🔗 Liens utiles + +::: {.nonincremental} + +- Installation R/RStudio : +- Utilisation de R/Rstudio en ligne : (Utilisez votre compte étudiant Paris 8 pour vous connecter) +- Guide des prompts efficaces : + + +::: + +## Contact et ressources + +::: {.nonincremental} +- 📧 **Email :** [elias.bouacida@univ-paris8.fr](mailto:elias.bouacida@univ-paris8.fr) +- 🌐 **Espace de cours :** [Moodle](https://moodle.univ-paris8.fr/course/view.php?id=18115) +- 🌐 **Cours :** [Cours](https://eliasbcd.github.io/rl3/) +- Bureau : Bâtiment D, Salle D115 +- Permanences : Mardi 14h-16h, Mercredi 14h-16h +::: + diff --git a/ECLibre/02Lecon1.qmd b/ECLibre/02Lecon1.qmd new file mode 100644 index 0000000..517bad0 --- /dev/null +++ b/ECLibre/02Lecon1.qmd @@ -0,0 +1,578 @@ +--- +title: "Séance 1 : Premiers pas avec R" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon1.html + embed-resources: true + footer: "Séance 1 - Premiers pas avec R" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Présentation** (15min) : Le cours et les outils +- **Découverte de l'interface RStudio** (30min) : Se repérer dans l'environnement +- **Premiers calculs** (30min) : R comme une calculatrice +- **Concepts de base** (60min) : Objets, assignation, types +- **Fonctions intégrées** (45min) : Utiliser des fonctions existantes +- **Premier script** (30min) : Organiser son code +::: + +::: {.fragment} +**Production attendue :** Journal de bord documentant votre découverte de R +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Découvrir R et apprendre avec les LLMs +::: + +::: {.incremental} +- Comprendre ce qu'est R et à quoi il sert +- Se familiariser avec **RStudio** +- Maîtriser les **concepts fondamentaux** : objets, types, fonctions +- Apprendre à **utiliser les LLMs** comme assistants d'apprentissage +- Commencer son **journal de bord** +::: + + +# Découverte de RStudio {background-color="#4169E1"} + +## Exercice 1 : Explorer l'interface {.smaller} + +Ouvrez RStudio sur votre ordinateur. + +::: {.fragment} +**Explorez ensuite :** + +1. La **console** (en bas à gauche généralement) +2. L'**éditeur** de scripts (en haut à gauche) +3. L'**environnement** (en haut à droite) +4. Les **fichiers/graphiques** (en bas à droite) +::: + +::: {.notes} +10 minutes. Laisser les étudiants découvrir l'interface. Circuler pour aider. Vérifier que tout le monde a RStudio installé et fonctionnel. +::: + +## Exercice 2 : La console interactive {.smaller} + +La **console** permet d'exécuter du code R directement. + +**Testez dans la console :** + +```{r} +#| eval: false +2 + 2 +``` + +::: {.fragment} +**Ensuite, essayez :** + +```{r} +#| eval: false +10 - 3 +5 * 4 +20 / 5 +``` +::: + +::: {.fragment} +::: {.callout-tip} +## Astuce +Appuyez sur **Entrée** pour exécuter. R affiche immédiatement le résultat ! +::: +::: + +::: {.notes} +10 minutes. Concept simple, mais fondamental. Insister sur l'aspect interactif. +::: + +# Premiers calculs {background-color="#FF8C00"} + +## R comme calculatrice + +R peut effectuer tous les calculs mathématiques de base. + +::: {.incremental} +- Addition : `+` +- Soustraction : `-` +- Multiplication : `*` +- Division : `/` +- Puissance : `^` +::: + +## Exercice 3 : Calculer une moyenne {.smaller} + +**Situation :** Dans votre classe, les notes sont 12, 15, 13 et 8. + +**Question :** Comment calculer la moyenne avec R ? + +::: {.fragment} +Demandez à votre LLM : + +> "Comment calculer la moyenne de ces notes en R : 12, 15, 13, 8 ?" +::: + +::: {.fragment} +**Testez le code proposé dans la console.** +::: + +::: {.notes} +15 minutes. Premier contact avec c() et mean(). Ne pas tout expliquer maintenant -- laisser les étudiants découvrir avec le LLM. +::: + +## Comprendre le code {.smaller} + +Vous avez probablement obtenu quelque chose comme : + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +mean(notes) +``` + +::: {.fragment} +**Demandez au LLM d'expliquer :** + +1. Que fait `c()` ? +2. Que signifie `<-` ? +3. Que fait `mean()` ? +::: + +::: {.fragment} +::: {.callout-note} +## Vocabulaire à découvrir +- **Vecteur** : `c()` crée une collection de valeurs +- **Assignation** : `<-` stocke une valeur dans un objet +- **Fonction** : `mean()` calcule la moyenne +::: +::: + +# Concepts fondamentaux {background-color="#8B008B"} + +## Les objets en R + +En R, on stocke des valeurs dans des **objets** (aussi appelés **variables**). + +::: {.fragment} +```{r} +#| eval: false +age <- 20 +nom <- "Alice" +est_etudiant <- TRUE +``` +::: + +::: {.fragment} +::: {.callout-tip} +## Analogie +Un objet est comme une boîte avec une étiquette (son nom) qui contient une valeur. +::: +::: + +## Exercice 4 : Créer des objets {.smaller} + +**Créez les objets suivants :** + +```{r} +#| eval: false +votre_prenom <- "..." +votre_age <- ... +annee_naissance <- 2025 - votre_age +``` + +Ensuite, affichez-les en tapant simplement leur nom dans la console. + +::: {.fragment} +**Questions à explorer avec le LLM :** + +1. Peut-on mettre des espaces dans les noms d'objets ? +2. Quelle est la différence entre `<-` et `=` ? +3. Comment supprimer un objet ? +::: + +::: {.notes} +15 minutes. Exercice pratique simple. Les étudiants découvrent les règles de nommage. +::: + +## Les types de données + +R distingue différents **types** de données : + +::: {.incremental} +- **Numérique** : `42`, `3.14` +- **Caractère** (texte) : `"Bonjour"`, `"Paris"` +- **Logique** : `TRUE`, `FALSE` +::: + +::: {.fragment} +**Pour vérifier le type :** + +```{r} +#| eval: false +age <- 20 +class(age) +``` +::: + +## Exercice 5 : Explorer les types {.smaller} + +**Demandez au LLM :** + +> "Explique-moi les différents types de données en R avec des exemples simples." + +**Ensuite, testez ce code et observez :** + +```{r} +#| eval: false +nombre <- 42 +texte <- "Hello" +vrai_faux <- TRUE + +class(nombre) +class(texte) +class(vrai_faux) +``` + +::: {.fragment} +**Question bonus :** Que se passe-t-il si on essaie d'additionner un nombre et du texte ? +::: + +::: {.notes} +15 minutes. Concept important. Les erreurs de type sont fréquentes pour les débutants. +::: + +## Les vecteurs + +Un **vecteur** est une collection de valeurs du même type. + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +prenoms <- c("Alice", "Bob", "Charlie") +``` + +::: {.fragment} +::: {.callout-note} +## Important +`c()` signifie "**c**ombine" - elle regroupe plusieurs valeurs. +::: +::: + +## Exercice 6 : Manipuler des vecteurs {.smaller} + +**Créez un vecteur avec les températures de la semaine :** + +```{r} +#| eval: false +temperatures <- c(18, 20, 19, 22, 21, 17, 16) +``` + +**Demandez au LLM comment :** + +1. Afficher la première température +2. Afficher les trois premières températures +3. Calculer la température moyenne +4. Trouver la température maximale + +::: {.fragment} +**Testez les solutions proposées !** +::: + +::: {.notes} +15 minutes. Introduction à l'indexation. Les étudiants découvriront [1], [1:3], max(), etc. +::: + +# Fonctions intégrées {background-color="#DC143C"} + +## Qu'est-ce qu'une fonction ? + +Une **fonction** est un outil qui prend des données en entrée et produit un résultat. + +::: {.fragment} +**Analogie :** Une fonction est comme une machine : + +- Vous lui donnez quelque chose (l'**entrée**) +- Elle effectue une opération +- Elle vous rend un résultat (la **sortie**) +::: + +## Exercice 7 : Découvrir des fonctions {.smaller} + +**Avec votre vecteur de températures, testez :** + +```{r} +#| eval: false +temperatures <- c(18, 20, 19, 22, 21, 17, 16) + +mean(temperatures) # moyenne +sum(temperatures) # somme +length(temperatures) # nombre d'éléments +min(temperatures) # minimum +max(temperatures) # maximum +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Quelles autres fonctions statistiques utiles existent en R pour analyser un vecteur de nombres ?" +::: + +::: {.notes} +15 minutes. Les étudiants découvrent les fonctions intégrées. Encourager l'exploration. +::: + +## Exercice 8 : L'aide en R {.smaller} + +Vous pouvez obtenir de l'aide sur n'importe quelle fonction avec `?` : + +```{r} +#| eval: false +?mean +?sum +``` + +::: {.fragment} +**Explorez :** + +1. Testez `?mean` dans la console +2. Où apparaît l'aide ? +3. Que signifie le paramètre `na.rm` ? +::: + +::: {.fragment} +::: {.callout-tip} +## Double source d'aide +- L'aide R (documentation officielle) +- Les LLMs (explications en langage naturel) + +**Utilisez les deux !** +::: +::: + +::: {.notes} +15 minutes. Concept important : devenir autonome. L'aide R est technique mais précise. +::: + +## Exercice 9 : Gérer les valeurs manquantes {.smaller} + +**Testez ce code :** + +```{r} +#| eval: false +notes_avec_absence <- c(12, 15, NA, 13, 8) +mean(notes_avec_absence) +``` + +::: {.fragment} +**Que se passe-t-il ?** + +`NA` signifie "**N**ot **A**vailable" (donnée manquante). +::: + +::: {.fragment} +**Demandez au LLM comment calculer la moyenne en ignorant les NA.** + +*Indice : regardez dans l'aide de `mean()` le paramètre `na.rm`* +::: + +::: {.notes} +15 minutes. Problème réel et fréquent. Les étudiants découvrent na.rm = TRUE. +::: + +# Premier script {background-color="#2F4F4F"} + +## Pourquoi un script ? + +Jusqu'ici, vous avez tapé dans la **console** (code éphémère). + +::: {.fragment} +Un **script** permet de : + +- **Sauvegarder** votre code +- Le **réutiliser** +- Le **partager** +- Le **commenter** +::: + +## Exercice 10 : Créer un script {.smaller} + +1. Cliquez sur **File > New File > R Script** +2. Dans ce nouveau fichier, écrivez : + +```{r} +#| eval: false +# Mon premier script R +# Auteur : [Votre nom] + +# Calcul de moyennes +notes <- c(12, 15, 13, 8) +moyenne <- mean(notes) + +print("La moyenne est :") +print(moyenne) +``` + +3. **Sauvegardez** (File > Save ou Ctrl+S) +4. **Exécutez** ligne par ligne (Ctrl+Entrée) + +::: {.notes} +20 minutes. Première sauvegarde de code. Insister sur les commentaires (#). +::: + +## Les commentaires + +Les lignes commençant par `#` sont des **commentaires** : + +```{r} +#| eval: false +# Ceci est un commentaire - R l'ignore +notes <- c(12, 15, 13, 8) # Commentaire après du code +``` + +::: {.fragment} +::: {.callout-tip} +## Bonne pratique +Commentez votre code pour expliquer **pourquoi** vous faites quelque chose, pas seulement **ce que** vous faites. +::: +::: + +## Exercice 11 : Script complet {.smaller} + +**Créez un script qui :** + +1. Crée un vecteur de températures sur 7 jours +2. Calcule la moyenne, le minimum et le maximum +3. Affiche ces résultats avec `print()` +4. Commente chaque étape + +::: {.fragment} +**Demandez au LLM de vous aider si nécessaire, mais essayez d'abord par vous-même !** +::: + +::: {.notes} +20 minutes. Exercice de synthèse. Les étudiants combinent tout ce qu'ils ont appris. +::: + +# Journal de bord et réflexion {background-color="#2E8B57"} + +## Votre journal de bord + +::: {.callout-note} +## Outil essentiel +Tout au long de ce cours, vous tiendrez un **journal de bord** documentant votre apprentissage. +::: + +::: {.incremental} +**Pour chaque séance, notez :** + +1. Les **prompts** que vous avez utilisés avec les LLMs +2. Les **réponses** obtenues (copier-coller) +3. Ce que vous avez **compris** +4. Les **difficultés** rencontrées +5. Les **solutions** trouvées +::: + +## Exercice 12 : Première entrée du journal {.smaller} + +**Dans votre journal, répondez à :** + +1. **Qu'est-ce qu'un objet en R ?** (avec vos propres mots) +2. **Qu'est-ce qu'une fonction ?** (donnez 3 exemples) +3. **Un prompt efficace** que vous avez utilisé aujourd'hui +4. **Une erreur** que vous avez rencontrée et comment vous l'avez résolue +5. **Une question** que vous vous posez encore + +::: {.fragment} +::: {.callout-tip} +## Conseil +Soyez précis ! Plus votre journal est détaillé, plus il vous sera utile. +::: +::: + +::: {.notes} +20 minutes. Moment réflexif important. Circuler pour voir les journaux. Donner des retours. +::: + +## Conseils pour les prompts + +::: {.incremental} +**Un bon prompt :** + +- Est **précis** : "Explique-moi les vecteurs en R" plutôt que "Parle-moi de R" +- Donne du **contexte** : "Je débute en programmation" +- Demande des **exemples** : "Avec un exemple simple" +- Peut être **affiné** : Si la réponse ne convient pas, reformulez ! +::: + +## Exemples de bons prompts + +::: {.callout-tip} +## Exemples + +- "Je débute en R. Peux-tu m'expliquer ce que fait c() avec un exemple concret ?" +- "J'ai cette erreur [copier l'erreur]. Qu'est-ce que ça signifie et comment la corriger ?" +- "Comment calculer la moyenne d'un vecteur contenant des NA en R ?" +::: + +# Ressources et prochaines étapes {background-color="#4169E1"} + +## Ce que vous avez appris aujourd'hui + +::: {.incremental} +✅ Utiliser RStudio +✅ Créer des objets avec `<-` +✅ Manipuler des vecteurs avec `c()` +✅ Utiliser des fonctions : `mean()`, `sum()`, `max()`, etc. +✅ Écrire et sauvegarder un script +✅ Commenter son code +✅ Utiliser les LLMs comme assistants +::: + +## Pour aller plus loin + +::: {.incremental} +- **Pratiquez** : La programmation s'apprend en faisant +- **Expérimentez** : Testez des fonctions, cassez des choses ! +- **Documentez** : Tenez votre journal à jour +- **Demandez** : Aux LLMs, à vos camarades, à l'enseignant +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez les exercices si besoin +2. **Mettez à jour votre journal de bord** +3. Créez un script avec une petite analyse de votre choix (notes, prix, âges, etc.) +4. Explorez 2 nouvelles fonctions et documentez-les dans votre journal +::: + +## Questions ? + +::: {.callout-tip} +## N'oubliez pas + +- R est un **outil** - il faut du temps pour le maîtriser +- Les **erreurs sont normales** et font partie de l'apprentissage +- Les LLMs sont des **assistants**, pas des remplaçants de votre cerveau +- **Testez toujours** le code avant de l'utiliser +::: + +::: {.fragment} +**Bienvenue dans l'aventure R ! 🚀** +::: diff --git a/ECLibre/03Lecon2Donnees.qmd b/ECLibre/03Lecon2Donnees.qmd new file mode 100644 index 0000000..2919280 --- /dev/null +++ b/ECLibre/03Lecon2Donnees.qmd @@ -0,0 +1,719 @@ +--- +title: "Séance 2 : Données et fonctions intégrées" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon2.html + embed-resources: true + footer: "Séance 2 - Données et fonctions" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (20min) : Retours sur vos journaux +- **Charger des données** (45min) : Importer des fichiers CSV +- **Exploration de données** (45min) : Structure et types de données +- **Statistiques descriptives** (45min) : Analyser les données +- **Visualisations de base** (45min) : Créer des graphiques +- **Mini-projet** (50min) : Analyser des données réelles +::: + +::: {.fragment} +**Production attendue :** Analyse commentée de données avec graphiques +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Manipuler de vraies données +::: + +::: {.incremental} +- **Importer** des données depuis des fichiers +- **Explorer** la structure des données (data frames) +- Calculer des **statistiques descriptives** +- Créer des **visualisations** simples +- Gérer les **données manquantes** +- **Débugger** avec l'aide des LLMs +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur la séance 1 + +::: {.incremental} +- Qu'avez-vous retenu de la semaine dernière ? +- Quels concepts restent flous ? +- Avez-vous pratiqué entre les séances ? +::: + +## Retours sur vos journaux {.smaller} + +::: {.callout-note} +## Conseils pour améliorer vos journaux +::: + +::: {.incremental} +- **Copier-coller** les prompts exacts que vous utilisez +- **Documenter** les réponses du LLM (pas juste des captures d'écran) +- **Expliquer avec vos propres mots** ce que vous avez compris +- **Noter les erreurs** rencontrées et comment vous les avez résolues +- **Éviter** les formats propriétaires (.pages) - préférer .docx ou .pdf +::: + +::: {.notes} +10 minutes. Discuter des journaux. Montrer des exemples anonymisés (bons et moins bons). +::: + +## Exercice de révision {.smaller} + +**Sans utiliser le LLM, écrivez un script qui :** + +1. Crée un vecteur avec 5 nombres de votre choix +2. Calcule la moyenne +3. Trouve le maximum +4. Affiche les résultats avec `print()` + +::: {.fragment} +**Ensuite, comparez avec votre voisin et discutez des différences.** +::: + +::: {.notes} +10 minutes. Révision active. Encourage la discussion entre étudiants. +::: + +# Charger des données {background-color="#4169E1"} + +## Des vecteurs aux données réelles + +Jusqu'ici, vous avez créé des données avec `c()` : + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +``` + +::: {.fragment} +**Dans la vraie vie**, les données viennent souvent de fichiers : CSV, Excel, bases de données, etc. +::: + +## Le format CSV + +::: {.callout-note} +## CSV = Comma Separated Values +Un format simple et universel pour stocker des données tabulaires. +::: + +::: {.fragment} +**Exemple de contenu CSV :** + +``` +nom,age,note +Alice,20,15 +Bob,22,12 +Charlie,21,14 +``` +::: + +## Exercice 1 : Télécharger les données {.smaller} + +1. Connectez-vous sur Moodle +2. Téléchargez le fichier `donnees_meteo.csv` +3. Placez-le dans votre dossier de travail + +::: {.fragment} +**Comment connaître votre dossier de travail ?** + +```{r} +#| eval: false +getwd() # "get working directory" +``` +::: + +::: {.fragment} +**Pour le changer :** + +```{r} +#| eval: false +setwd("/chemin/vers/votre/dossier") +``` + +Ou utilisez **Session > Set Working Directory** dans RStudio. +::: + +::: {.notes} +10 minutes. S'assurer que tout le monde a les données au bon endroit. Circuler pour aider. +::: + +## Exercice 2 : Importer les données {.smaller} + +**Demandez à votre LLM :** + +> "Comment importer un fichier CSV en R ? Je débute en programmation." + +::: {.fragment} +Vous devriez obtenir quelque chose comme : + +```{r} +#| eval: false +donnees_meteo <- read.csv("donnees_meteo.csv") +``` +::: + +::: {.fragment} +**Testez cette commande !** + +En cas d'erreur, demandez au LLM de vous aider à débugger. +::: + +::: {.notes} +15 minutes. Première importation de données. Anticiper les erreurs de chemin, d'encodage, etc. +::: + +## Vérifier l'importation + +Une fois importé, vérifiez que ça a fonctionné : + +```{r} +#| eval: false +# Afficher les premières lignes +head(donnees_meteo) + +# Afficher la structure +str(donnees_meteo) +``` + +::: {.fragment} +**Demandez au LLM d'expliquer ce que montrent ces fonctions.** +::: + +# Exploration de données {background-color="#FF8C00"} + +## Les data frames + +Les données importées sont stockées dans un **data frame**. + +::: {.fragment} +::: {.callout-tip} +## Analogie +Un data frame est comme un tableau Excel : des lignes (observations) et des colonnes (variables). +::: +::: + +## Exercice 3 : Explorer la structure {.smaller} + +**Avec vos données météo, testez :** + +```{r} +#| eval: false +# Nombre de lignes et colonnes +nrow(donnees_meteo) +ncol(donnees_meteo) +dim(donnees_meteo) # les deux à la fois + +# Noms des colonnes +names(donnees_meteo) +colnames(donnees_meteo) + +# Résumé rapide +summary(donnees_meteo) +``` + +::: {.fragment} +**Questions :** + +1. Combien d'observations avez-vous ? +2. Quelles variables (colonnes) sont présentes ? +3. Quel type de données contient chaque colonne ? +::: + +::: {.notes} +15 minutes. Découverte des fonctions d'exploration. Essentielles pour comprendre les données. +::: + +## Accéder aux colonnes + +Pour accéder à une colonne spécifique, utilisez `$` : + +```{r} +#| eval: false +donnees_meteo$temperature +donnees_meteo$date +``` + +::: {.fragment} +**Cela retourne un vecteur !** Vous pouvez donc utiliser toutes les fonctions que vous connaissez : + +```{r} +#| eval: false +mean(donnees_meteo$temperature) +max(donnees_meteo$temperature) +``` +::: + +## Exercice 4 : Analyser les variables {.smaller} + +**Pour chaque variable numérique dans vos données, calculez :** + +1. La moyenne +2. La médiane +3. Le minimum +4. Le maximum +5. L'écart-type (`sd()`) + +::: {.fragment} +**Demandez au LLM :** + +> "Comment calculer des statistiques descriptives sur une colonne d'un data frame en R ?" +::: + +::: {.fragment} +**Notez vos résultats dans un commentaire de votre script.** +::: + +::: {.notes} +15 minutes. Application pratique. Les étudiants utilisent $ et les fonctions statistiques. +::: + +# Statistiques descriptives {background-color="#8B008B"} + +## La fonction `summary()` + +`summary()` donne un aperçu rapide : + +```{r} +#| eval: false +summary(donnees_meteo$temperature) +``` + +::: {.fragment} +Elle affiche : + +- Minimum et maximum +- 1er quartile, médiane, 3e quartile +- Moyenne +::: + +## Exercice 5 : Comparer avec vos calculs {.smaller} + +**Comparez vos calculs précédents avec `summary()` :** + +```{r} +#| eval: false +# Vos calculs +mean(donnees_meteo$temperature) +median(donnees_meteo$temperature) +min(donnees_meteo$temperature) +max(donnees_meteo$temperature) + +# Summary +summary(donnees_meteo$temperature) +``` + +::: {.fragment} +**Questions :** + +1. Les résultats correspondent-ils ? +2. Que signifie "médiane" ? (Demandez au LLM si vous ne savez pas) +3. Que signifient les quartiles ? +::: + +::: {.notes} +15 minutes. Vérification et approfondissement. Introduction aux quartiles. +::: + +## Gérer les valeurs manquantes (NA) {.smaller} + +**Testez ce code :** + +```{r} +#| eval: false +# Y a-t-il des NA dans vos données ? +sum(is.na(donnees_meteo$temperature)) + +# Afficher les lignes avec des NA +donnees_meteo[is.na(donnees_meteo$temperature), ] +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Comment gérer les valeurs manquantes (NA) lors du calcul de statistiques en R ?" +::: + +::: {.fragment} +Vous découvrirez le paramètre `na.rm = TRUE` : + +```{r} +#| eval: false +mean(donnees_meteo$temperature, na.rm = TRUE) +``` +::: + +::: {.notes} +15 minutes. Problème réel très fréquent. Important de comprendre na.rm. +::: + +## Exercice 6 : Rapport statistique {.smaller} + +**Créez un script qui génère un rapport complet sur la variable température :** + +```{r} +#| eval: false +# Rapport sur la température +print("=== ANALYSE DE LA TEMPÉRATURE ===") +print(paste("Nombre d'observations :", length(donnees_meteo$temperature))) +print(paste("Valeurs manquantes :", sum(is.na(donnees_meteo$temperature)))) +print(paste("Moyenne :", mean(donnees_meteo$temperature, na.rm = TRUE))) +print(paste("Médiane :", median(donnees_meteo$temperature, na.rm = TRUE))) +print(paste("Écart-type :", sd(donnees_meteo$temperature, na.rm = TRUE))) +``` + +::: {.fragment} +**Extension :** Faites la même chose pour une autre variable. +::: + +::: {.notes} +15 minutes. Exercice de synthèse. Introduction à paste() pour formater. +::: + +# Visualisations {background-color="#DC143C"} + +## Pourquoi visualiser ? + +::: {.incremental} +- Les chiffres ne suffisent pas toujours +- Un graphique révèle des **patterns** invisibles dans les tableaux +- Communiquer plus efficacement +::: + +## Exercice 7 : Premier graphique {.smaller} + +**Demandez au LLM :** + +> "Comment créer un graphique simple en R pour visualiser l'évolution d'une variable dans le temps ? Je débute." + +::: {.fragment} +Vous découvrirez probablement `plot()` : + +```{r} +#| eval: false +plot(donnees_meteo$date, donnees_meteo$temperature) +``` +::: + +::: {.fragment} +**Testez ce code !** + +Si vous avez une erreur avec les dates, demandez au LLM comment les convertir au bon format. +::: + +::: {.notes} +15 minutes. Premier graphique. Les dates peuvent poser problème - bon exercice de debugging. +::: + +## Améliorer le graphique {.smaller} + +Les graphiques de base peuvent être personnalisés : + +```{r} +#| eval: false +plot(donnees_meteo$date, donnees_meteo$temperature, + type = "l", # ligne au lieu de points + col = "blue", + main = "Évolution de la température", + xlab = "Date", + ylab = "Température (°C)") +``` + +::: {.fragment} +**Demandez au LLM d'expliquer chaque paramètre.** +::: + +## Exercice 8 : Explorer d'autres graphiques {.smaller} + +**Demandez au LLM comment créer :** + +1. Un histogramme de la température +2. Un boxplot (boîte à moustaches) +3. Un graphique de points (scatter plot) si vous avez deux variables numériques + +::: {.fragment} +**Testez chaque type et notez dans votre journal :** + +- La commande utilisée +- Ce que montre le graphique +- Quand l'utiliser +::: + +::: {.notes} +20 minutes. Exploration des types de graphiques. Encourager la curiosité. +::: + +## Sauvegarder un graphique + +Pour sauvegarder un graphique : + +```{r} +#| eval: false +# Ouvrir un fichier +png("mon_graphique.png", width = 800, height = 600) + +# Créer le graphique +plot(donnees_meteo$date, donnees_meteo$temperature, type = "l") + +# Fermer le fichier +dev.off() +``` + +::: {.fragment} +Le fichier sera dans votre dossier de travail. +::: + +# Debugging {background-color="#2F4F4F"} + +## Les erreurs sont normales ! + +::: {.callout-warning} +## Important +Tout le monde rencontre des erreurs. C'est une partie essentielle de la programmation. +::: + +::: {.fragment} +**Stratégie de debugging :** + +1. **Lire** le message d'erreur (même s'il semble cryptique) +2. **Identifier** la ligne problématique +3. **Tester** des hypothèses +4. **Demander** de l'aide (LLM, documentation, pairs) +::: + +## Exercice 9 : Debugging collectif {.smaller} + +**Voici du code avec des erreurs. Trouvez-les et corrigez-les :** + +```{r} +#| eval: false +# Charger les données +donnees <- read.csv(donnees_meteo.csv) + +# Calculer la moyenne +moyenne_temp <- mean(donnees$Temperature) + +# Afficher +print("La moyenne est" moyenne_temp) +``` + +::: {.fragment} +**Travaillez par groupes de 2-3. Utilisez le LLM si nécessaire.** +::: + +::: {.fragment} +**Erreurs à trouver :** + +1. Guillemets manquants autour du nom de fichier +2. Majuscule incorrecte dans le nom de colonne +3. Virgule manquante dans `print()` +::: + +::: {.notes} +15 minutes. Exercice collectif. Discuter ensuite des types d'erreurs courantes. +::: + +## Bien utiliser le LLM pour débugger {.smaller} + +::: {.callout-tip} +## Comment demander de l'aide efficacement +::: + +**Mauvais prompt :** +> "Ça marche pas" + +**Bon prompt :** +> "J'essaie d'importer un fichier CSV avec read.csv() mais j'obtiens cette erreur : [copier l'erreur exacte]. Voici mon code : [copier le code]. Que dois-je corriger ?" + +::: {.fragment} +**Donnez toujours :** + +- Le code exact +- L'erreur complète +- Ce que vous essayez de faire +- Votre niveau (débutant) +::: + +# Mini-projet {background-color="#2E8B57"} + +## Projet : Analyse de données INSEE {.smaller} + +**Objectif :** Analyser des données économiques réelles. + +**Étapes :** + +1. Allez sur +2. Téléchargez les données du PIB (format CSV de préférence) +3. Importez-les dans R +4. Créez un rapport complet + +::: {.callout-note} +## Rapport attendu +- Import et vérification des données +- Statistiques descriptives +- Au moins 2 graphiques +- Commentaires expliquant vos observations +::: + +::: {.notes} +50 minutes. Projet autonome. Circuler beaucoup. Les étudiants vont rencontrer des difficultés (format de données, etc.) - c'est normal et formateur. +::: + +## Critères du mini-projet {.smaller} + +Votre analyse doit inclure : + +::: {.incremental} +- ✅ Import réussi des données +- ✅ Exploration de la structure (`str()`, `summary()`, etc.) +- ✅ Au moins 5 statistiques descriptives calculées +- ✅ Au moins 2 visualisations différentes +- ✅ Code commenté et organisé +- ✅ Interprétation des résultats (commentaires en français) +::: + +::: {.fragment} +**Bonus :** + +- Gestion des NA +- Graphiques personnalisés +- Comparaison entre plusieurs variables +::: + +## Aide pour le projet {.smaller} + +**Si vous êtes bloqué :** + +1. Relisez les exercices précédents +2. Consultez votre journal +3. Demandez à votre voisin +4. Utilisez le LLM avec un prompt précis +5. Appelez l'enseignant + +::: {.fragment} +::: {.callout-tip} +## Conseil +Procédez par étapes. Testez chaque ligne avant de passer à la suivante. +::: +::: + +# Retour réflexif {background-color="#4169E1"} + +## Exercice de synthèse : Journal de bord {.smaller} + +**Dans votre journal, documentez :** + +1. **Import de données** : + - Prompts utilisés pour apprendre à importer + - Difficultés rencontrées (chemins, formats, etc.) + - Solutions trouvées + +2. **Analyse et visualisation** : + - 3 fonctions nouvelles que vous maîtrisez maintenant + - Un graphique dont vous êtes fier (copier le code) + - Une chose que vous ne comprenez pas encore + +3. **Debugging** : + - Une erreur marquante et comment vous l'avez résolue + - Un bon prompt de debugging qui a fonctionné + +::: {.notes} +15 minutes. Temps de réflexion calme. Important pour ancrer les apprentissages. +::: + +## Évolution de vos compétences + +::: {.incremental} +**Séance 1 :** Vous avez appris les bases (objets, fonctions, vecteurs) + +**Séance 2 :** Vous savez maintenant : + +- Importer des données réelles +- Les explorer et les analyser +- Créer des visualisations +- Débugger efficacement +::: + +::: {.fragment} +**Vous êtes déjà capable d'analyser de vraies données ! 🎉** +::: + +# Ressources et prochaines étapes {background-color="#8B008B"} + +## Fonctions clés de cette séance + +::: {.incremental} +**Import et exploration :** + +- `read.csv()`, `getwd()`, `setwd()` +- `head()`, `str()`, `summary()`, `dim()`, `names()` + +**Statistiques :** + +- `mean()`, `median()`, `sd()`, `min()`, `max()` +- `na.rm = TRUE` pour gérer les NA + +**Visualisation :** + +- `plot()`, `hist()`, `boxplot()` +- Paramètres : `type`, `col`, `main`, `xlab`, `ylab` +::: + +## Pour aller plus loin + +::: {.incremental} +- **Pratiquez** avec d'autres jeux de données +- **Explorez** d'autres types de graphiques +- **Découvrez** le package `ggplot2` (pour plus tard) +- **Partagez** vos visualisations avec vos camarades +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez le mini-projet INSEE si besoin +2. **Mettez à jour votre journal** avec tous les détails de cette séance +3. Trouvez un jeu de données qui vous intéresse et analysez-le +4. Créez au moins 3 graphiques différents avec vos données +::: + +::: {.fragment} +**Prochaine séance :** Fonctions, conditions et boucles - automatiser vos analyses ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Les **data frames** sont essentiels pour travailler avec des données réelles +- `$` permet d'accéder aux colonnes +- Toujours vérifier les **NA** avant de calculer +- Les **visualisations** révèlent ce que les chiffres cachent +- Le **debugging** fait partie du processus - soyez patient ! +::: + +::: {.fragment} +**Bon courage et bonnes analyses ! 📊** +::: + diff --git a/ECLibre/04Lecon3Fonctions.qmd b/ECLibre/04Lecon3Fonctions.qmd new file mode 100644 index 0000000..11137d1 --- /dev/null +++ b/ECLibre/04Lecon3Fonctions.qmd @@ -0,0 +1,478 @@ +--- +title: "Séance 3 : Fonctions, conditions et boucles" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon3.html + embed-resources: true + footer: "Séance 3 - Fonctions, conditions et boucles" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur les données +- **Conditions if/else** (45min) : Prendre des décisions dans le code +- **Boucles** (45min) : Répéter des opérations +- **Créer ses propres fonctions** (60min) : Structurer son code +- **Mini-projet** (45min) : Analyser des données avec vos fonctions +::: + +::: {.fragment} +**Production attendue :** 3 fonctions personnalisées avec conditions et/ou boucles +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Automatiser et structurer son code +::: + +::: {.incremental} +- Utiliser des **conditions** pour adapter le comportement du code +- Utiliser des **boucles** pour répéter des opérations +- **Créer des fonctions** réutilisables +- **Combiner** ces concepts pour résoudre des problèmes réels +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur vos analyses de données + +::: {.incremental} +- Quelles difficultés avez-vous rencontrées ? +- Quelles fonctions intégrées avez-vous découvertes ? +- Comment les LLMs vous ont-ils aidé ? +::: + +# Conditions if/else {background-color="#4169E1"} + +## Pourquoi des conditions ? + +::: {.callout-note} +## Question +Imaginez que vous analysez des températures. Comment indiquer s'il fait chaud ou froid ? +::: + +::: {.fragment} +On a besoin de **tester une condition** et agir différemment selon le résultat. +::: + +## Exercice 1 : Première condition {.smaller} + +Demandez à votre LLM de vous expliquer la structure `if/else` en R avec un exemple simple. + +**Ensuite, testez ce code :** + +```{r} +#| eval: false +temperature <- 25 + +if (temperature > 20) { + print("Il fait chaud") +} +``` + +**Questions à explorer avec votre LLM :** + +1. Que se passe-t-il si `temperature <- 15` ? +2. Comment ajouter un message pour "Il fait froid" ? +3. Qu'est-ce qu'un opérateur de comparaison ? (`>`, `<`, `==`, `!=`, `>=`, `<=`) + +::: {.notes} +Laisser 10 minutes. Circuler pour vérifier la compréhension. Insister sur le fait que le LLM peut se tromper - tester le code est essentiel. +::: + +## Exercice 2 : if/else complet {.smaller} + +Créez un code qui : + +- Prend une note (0-20) +- Affiche "Réussite" si la note est >= 10 +- Affiche "Échec" sinon + +::: {.fragment} +**Extension :** Ajoutez une troisième catégorie avec `else if` : + +- "Excellent" si >= 16 +- "Réussite" si >= 10 +- "Échec" sinon +::: + +::: {.notes} +10 minutes. Faire un débriefing collectif. Demander à un étudiant de partager son code et son prompt. +::: + +## Exercice 3 : Conditions et vecteurs {.smaller} + +**Problème :** Vous avez plusieurs notes : + +```{r} +#| eval: false +notes <- c(8, 12, 15, 9, 18) +``` + +**Question :** Comment classifier TOUTES ces notes ? + +Demandez à votre LLM comment appliquer une condition à un vecteur. + +::: {.fragment} +**Indices à explorer :** + +- La fonction `ifelse()` +- La différence entre `if` et `ifelse()` +::: + +::: {.notes} +15 minutes. C'est un concept important. Les étudiants découvriront la vectorisation. Certains LLMs proposeront des boucles, d'autres `ifelse()`. Discuter les deux approches. +::: + +# Boucles {background-color="#FF8C00"} + +## Pourquoi des boucles ? + +::: {.callout-note} +## Situation +Vous avez 100 températures à classifier. Écrire 100 fois `if/else` ? +::: + +::: {.fragment} +Les **boucles** permettent de répéter automatiquement des opérations. +::: + +## Exercice 4 : Boucle for simple {.smaller} + +Demandez à votre LLM d'expliquer la boucle `for` en R avec un exemple. + +**Testez ce code :** + +```{r} +#| eval: false +for (i in 1:5) { + print(i) +} +``` + +**Questions :** + +1. Que fait `1:5` ? +2. Que représente `i` ? +3. Comment afficher les nombres de 10 à 20 ? + +::: {.notes} +10 minutes. Concept fondamental mais peut être abstrait pour certains. +::: + +## Exercice 5 : Boucle sur un vecteur {.smaller} + +Reprenez vos notes de l'exercice 3 : + +```{r} +#| eval: false +notes <- c(8, 12, 15, 9, 18) +``` + +Utilisez une boucle `for` pour : + +1. Afficher chaque note +2. Afficher chaque note avec son classement (Réussite/Échec) + +::: {.fragment} +**Astuce :** Combinez `for` et `if/else` ! +::: + +::: {.notes} +15 minutes. Les étudiants vont combiner les deux concepts. Anticiper les confusions entre i (indice) et notes[i] (valeur). +::: + +## Exercice 6 : Accumuler des résultats {.smaller} + +**Nouveau défi :** Calculez la somme des notes **sans utiliser** `sum()`. + +**Indices :** + +1. Créez une variable `total <- 0` +2. Utilisez une boucle pour ajouter chaque note à `total` +3. Affichez le résultat final + +::: {.fragment} +**Vérification :** Comparez avec `sum(notes)` +::: + +::: {.notes} +10 minutes. Introduit le concept d'accumulation. Utile pour comprendre ce que font réellement les fonctions intégrées. +::: + +## Boucle while (optionnel) {.smaller} + +Demandez à votre LLM la différence entre `for` et `while`. + +**Exemple à tester :** + +```{r} +#| eval: false +compteur <- 1 +while (compteur <= 5) { + print(compteur) + compteur <- compteur + 1 +} +``` + +::: {.callout-warning} +## Attention ! +Que se passe-t-il si vous oubliez `compteur <- compteur + 1` ? +::: + +::: {.notes} +Optionnel car `while` est moins utilisé en R. Mais bon pour comprendre les concepts de programmation. Attention aux boucles infinies ! +::: + +# Créer ses fonctions {background-color="#8B008B"} + +## Pourquoi créer des fonctions ? + +Jusqu'ici, vous avez **utilisé** des fonctions : `mean()`, `sum()`, `print()`... + +::: {.fragment} +Maintenant, vous allez **créer** vos propres fonctions ! +::: + +::: {.fragment} +::: {.callout-tip} +## Avantages +- Réutiliser du code +- Éviter la répétition +- Rendre le code plus lisible +- Partager avec d'autres +::: +::: + +## Exercice 7 : Première fonction {.smaller} + +Demandez à votre LLM d'expliquer comment créer une fonction en R. + +**Créez une fonction simple :** + +```{r} +#| eval: false +dire_bonjour <- function(nom) { + message <- paste("Bonjour", nom) + return(message) +} + +# Test +dire_bonjour("Alice") +``` + +**Questions :** + +1. À quoi sert `function()` ? +2. Qu'est-ce qu'un **paramètre** / **argument** ? +3. À quoi sert `return()` ? + +::: {.notes} +15 minutes. Première fonction. Bien distinguer définition (function) et appel (dire_bonjour("Alice")). +::: + +## Exercice 8 : Fonction avec condition {.smaller} + +Créez une fonction `classifier_note()` qui : + +- Prend une note en paramètre +- Retourne "Excellent" si >= 16 +- Retourne "Réussite" si >= 10 +- Retourne "Échec" sinon + +**Testez avec plusieurs valeurs.** + +::: {.fragment} +**Extension :** Que se passe-t-il si on passe une note négative ou > 20 ? Comment améliorer la fonction ? +::: + +::: {.notes} +15 minutes. Première fonction "utile". L'extension introduit la validation des paramètres (concept important). +::: + +## Exercice 9 : Fonction avec boucle {.smaller} + +Créez une fonction `calculer_moyenne()` qui : + +- Prend un vecteur de nombres +- Utilise une boucle pour calculer la moyenne +- Retourne le résultat + +**Testez :** + +```{r} +#| eval: false +mes_notes <- c(12, 15, 8, 14) +calculer_moyenne(mes_notes) +``` + +::: {.fragment} +**Questions :** + +1. Comment gérer les valeurs manquantes (`NA`) ? +2. Comparez votre résultat avec `mean()` +::: + +::: {.notes} +15 minutes. Fonction plus complexe. Les étudiants réutilisent l'exercice 6. Discussion sur NA importante. +::: + +## Exercice 10 : Fonction complète {.smaller} + +Créez une fonction `analyser_vecteur()` qui prend un vecteur et retourne : + +- Le minimum +- Le maximum +- La moyenne +- Le nombre d'éléments + +::: {.fragment} +**Défi :** Comment retourner plusieurs valeurs ? Demandez au LLM ! + +*Indice : liste ou vecteur nommé* +::: + +::: {.notes} +15 minutes. Fonction avancée. Introduit le concept de retourner des structures de données complexes. Les étudiants découvriront les listes. +::: + +# Mini-projet {background-color="#DC143C"} + +## Projet : Analyse de températures {.smaller} + +Vous allez créer un petit système d'analyse météo. + +**Données :** + +```{r} +#| eval: false +temperatures <- c(15, 22, 18, 25, 12, 28, 20, 16, 24, 19) +``` + +**Créez les fonctions suivantes :** + +1. `classifier_temperature(temp)` : retourne "Froid", "Doux" ou "Chaud" +2. `compter_par_categorie(vecteur_temp)` : compte combien de jours froids/doux/chauds +3. `rapport_meteo(vecteur_temp)` : génère un rapport complet (min, max, moyenne, catégories) + +::: {.callout-note} +## Utilisez tout ce que vous avez appris +Conditions, boucles, fonctions ! +::: + +::: {.notes} +45 minutes. Projet synthèse. Les étudiants combinent tous les concepts. Circuler beaucoup. Encourager l'aide entre pairs. Certains iront plus loin (graphiques, etc.). +::: + +## Critères du mini-projet {.smaller} + +Votre code doit : + +::: {.incremental} +- ✅ Fonctionner sans erreur +- ✅ Contenir au moins 3 fonctions +- ✅ Utiliser des conditions (`if/else`) +- ✅ Utiliser au moins une boucle +- ✅ Être commenté (expliquez ce que fait chaque fonction) +::: + +::: {.fragment} +**Bonus :** + +- Gérer les cas d'erreur (NA, vecteur vide, etc.) +- Créer des visualisations +- Tester avec d'autres données +::: + +::: {.notes} +Afficher les critères clairement. Certains étudiants auront besoin de plus de temps - c'est OK. +::: + +# Retour sur l'utilisation des LLMs {background-color="#2F4F4F"} + +## Pièges courants avec les LLMs + +::: {.callout-warning} +## Attention ! +Les LLMs peuvent : + +- Proposer du code qui ne fonctionne pas +- Utiliser des fonctions qui n'existent pas +- Mélanger différentes versions de R +- Donner des explications approximatives +::: + +::: {.fragment} +**Votre responsabilité :** TOUJOURS tester le code ! +::: + +## Exercice réflexif : Journal de bord {.smaller} + +Dans votre journal, documentez : + +1. **Un prompt qui a bien fonctionné** : Pourquoi ? +2. **Une erreur du LLM** : Comment l'avez-vous détectée ? Corrigée ? +3. **Votre code le plus complexe** : Expliquez-le avec vos mots +4. **Une chose que vous ne comprenez pas encore** : À approfondir + +::: {.fragment} +::: {.callout-tip} +## Conseil +Plus vous serez précis dans vos prompts, meilleures seront les réponses. Donnez du contexte ! +::: +::: + +::: {.notes} +10 dernières minutes. Moment réflexif important. Les étudiants prennent du recul sur leur apprentissage. +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Pour aller plus loin + +::: {.incremental} +- **Documentation R :** `?function`, `?if`, `?for` +- **Pratiquez :** La programmation s'apprend en codant ! +- **Debuggez :** Les erreurs sont normales et instructives +- **Partagez :** Discutez de vos solutions avec vos pairs +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs +1. Terminez le mini-projet si besoin +2. Mettez à jour votre journal de bord +3. Créez au moins une fonction originale qui vous serait utile +::: + +::: {.fragment} +**Questions à explorer :** Comment sauvegarder ses fonctions ? Comment les partager ? (→ scripts, packages) +::: + +## Questions ? + +::: {.callout-tip} +## N'oubliez pas +- Testez votre code +- Commentez votre code +- Documentez votre apprentissage +- Utilisez les LLMs comme **assistants**, pas comme **rédacteurs** +::: + +::: {.fragment} +**Bon courage et bon code ! 🚀** +::: \ No newline at end of file diff --git a/ECLibre/05Lecon4Dataframes.qmd b/ECLibre/05Lecon4Dataframes.qmd new file mode 100644 index 0000000..c1b4a00 --- /dev/null +++ b/ECLibre/05Lecon4Dataframes.qmd @@ -0,0 +1,574 @@ +--- +title: "Séance 4 : Données tabulaires et graphiques avancés" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon4.html + embed-resources: true + footer: "Séance 4 - Données tabulaires et graphiques avancés" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur les fonctions +- **Nettoyage de données** (60min) : Gérer les incohérences réelles +- **Introduction à ggplot2** (75min) : Créer des graphiques sophistiqués +- **Fonctions de visualisation** (40min) : Automatiser la création de graphiques +- **Mini-projet** (40min) : Dashboard de visualisations +::: + +::: {.fragment} +**Production attendue :** Dashboard avec 4 graphiques + fonction de visualisation réutilisable +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Maîtriser les données complexes et la visualisation +::: + +::: {.incremental} +- **Nettoyer** des données avec incohérences (casse, formats) +- Maîtriser les **dataframes** avancés +- Créer des **visualisations** avec ggplot2 +- Développer des **fonctions graphiques** réutilisables +- Combiner analyse et communication visuelle +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur les fonctions + +::: {.incremental} +- Quelles fonctions avez-vous créées ? +- Quelles difficultés avec les conditions et boucles ? +- Un exemple de bug intéressant que vous avez résolu ? +::: + +## Exercice de révision {.smaller} + +**Créez rapidement une fonction qui :** + +1. Prend un vecteur de nombres en paramètre +2. Retourne "Positif" si la moyenne est > 0 +3. Retourne "Négatif" sinon +4. Gère les NA correctement + +::: {.fragment} +**Testez avec :** + +```{r} +#| eval: false +valeurs <- c(-5, 10, NA, 8, -3) +classifier_moyenne(valeurs) +``` +::: + +::: {.notes} +10 minutes. Révision rapide. Vérifier que les concepts de la séance 3 sont acquis. +::: + +# Données réelles et leurs problèmes {background-color="#4169E1"} + +## Les données ne sont jamais parfaites + +Dans le monde réel, les données contiennent souvent : + +::: {.incremental} +- Des **problèmes de casse** : "Alice", "alice", "ALICE" +- Des **formats incohérents** : "2023-01-15", "15/01/2023" +- Des **valeurs manquantes** : NA, "", "N/A", "inconnu" +- Des **doublons** +- Des **erreurs de saisie** +::: + +::: {.fragment} +::: {.callout-warning} +## Important +Le nettoyage des données représente souvent 80% du travail d'analyse ! +::: +::: + +## Exercice 1 : Découvrir les problèmes {.smaller} + +**Voici un jeu de données de ventes :** + +```{r} +#| eval: false +ventes <- data.frame( + mois = c("Jan", "Fév", "Mar", "Avr", "Mai", "Jun"), + montant = c(1500, 2000, NA, 1800, 2200, 1900), + vendeur = c("Alice", "Bob", "alice", "Bob", "Alice", "bob") +) +``` + +**Demandez au LLM :** + +> "Quels sont les problèmes potentiels dans ce jeu de données pour une analyse ?" + +::: {.fragment} +**Identifiez :** + +1. Le problème de casse dans les noms +2. La valeur manquante +3. Les conséquences pour les calculs par vendeur +::: + +::: {.notes} +15 minutes. Les étudiants découvrent les problèmes réels des données. +::: + +## Exercice 2 : Nettoyer la casse {.smaller} + +**Problème :** Les noms "Alice", "alice" et "Bob", "bob" sont comptés séparément. + +**Demandez au LLM comment standardiser les noms.** + +::: {.fragment} +Vous découvrirez probablement : + +```{r} +#| eval: false +ventes$vendeur <- tolower(ventes$vendeur) +# ou +ventes$vendeur <- toupper(ventes$vendeur) +``` +::: + +::: {.fragment} +**Vérifiez le résultat :** + +```{r} +#| eval: false +unique(ventes$vendeur) +table(ventes$vendeur) +``` +::: + +::: {.notes} +15 minutes. Premier nettoyage simple mais essentiel. +::: + +## Exercice 3 : Gérer les valeurs manquantes {.smaller} + +**Plusieurs stratégies possibles :** + +**Demandez au LLM :** + +> "Comment gérer les valeurs NA dans mes données de ventes ? Quelles sont les différentes approches ?" + +::: {.fragment} +**Options principales :** + +1. **Supprimer** les lignes avec NA : `na.omit()` +2. **Remplacer** par une valeur : moyenne, médiane, 0 +3. **Garder** mais utiliser `na.rm = TRUE` dans les calculs +::: + +::: {.fragment} +::: {.callout-note} +## Réflexion importante +Quelle stratégie choisir dépend du contexte ! Supprimer des données peut introduire des biais. +::: +::: + +::: {.notes} +15 minutes. Discussion importante sur les choix méthodologiques. +::: + +## Exercice 4 : Dataset complexe piégé {.smaller} + +**Nouveau challenge - Données étudiants :** + +```{r} +#| eval: false +etudiants <- data.frame( + nom = c("Dupont", "Martin", "Durand", "", "Petit"), + age = c(20, "vingt-deux", 19, 21, 18), + note_math = c(15, 12, NA, 16, 14), + note_info = c(13, NA, 15, 12, 16), + filiere = c("Info", "info", "Maths", "INFO", "maths") +) +``` + +**Mission :** + +1. Identifiez TOUS les problèmes +2. Nettoyez le dataset +3. Calculez la moyenne par filière + +::: {.fragment} +**Utilisez le LLM étape par étape !** +::: + +::: {.notes} +30 minutes. Exercice de synthèse sur le nettoyage. Beaucoup d'erreurs à trouver. +::: + +# Introduction à ggplot2 {background-color="#FF8C00"} + +## Pourquoi ggplot2 ? + +Jusqu'ici vous avez utilisé `plot()`, `hist()`, `barplot()`... + +::: {.fragment} +**ggplot2** est un package puissant pour créer des graphiques : + +- Syntaxe cohérente et logique +- Graphiques professionnels +- Très flexible et personnalisable +- Standard dans l'analyse de données en R +::: + +## La grammaire des graphiques + +**ggplot2** fonctionne par couches : + +::: {.incremental} +1. **Données** : `ggplot(data = mes_donnees)` +2. **Esthétiques** : `aes(x = variable1, y = variable2)` +3. **Géométries** : `geom_point()`, `geom_line()`, `geom_bar()` +4. **Personnalisation** : titres, couleurs, thèmes +::: + +::: {.fragment} +On **ajoute** des couches avec `+` +::: + +## Exercice 5 : Premier graphique ggplot2 {.smaller} + +**Demandez au LLM :** + +> "Comment créer un graphique simple avec ggplot2 en R ? Je débute avec ce package." + +**Ensuite, testez avec vos données de ventes :** + +```{r} +#| eval: false +library(ggplot2) + +ggplot(data = ventes, aes(x = mois, y = montant)) + + geom_col() +``` + +::: {.fragment} +**Questions :** + +1. Que fait `aes()` ? +2. Pourquoi `geom_col()` et pas `geom_bar()` ? +3. Comment changer la couleur des barres ? +::: + +::: {.notes} +20 minutes. Première découverte de ggplot2. La syntaxe peut surprendre au début. +::: + +## Exercice 6 : Améliorer le graphique {.smaller} + +**Personnalisez votre graphique :** + +```{r} +#| eval: false +ggplot(data = ventes, aes(x = mois, y = montant)) + + geom_col(fill = "steelblue") + + labs( + title = "Ventes mensuelles", + x = "Mois", + y = "Montant (€)" + ) + + theme_minimal() +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Comment personnaliser les couleurs, titres et thème d'un graphique ggplot2 ?" +::: + +::: {.fragment} +**Explorez :** + +- Différentes couleurs +- Différents thèmes : `theme_bw()`, `theme_classic()` +- Ajout d'une ligne à un niveau spécifique avec `geom_hline()` +::: + +::: {.notes} +20 minutes. Exploration des options de personnalisation. +::: + +## Exercice 7 : Différents types de graphiques {.smaller} + +**Demandez au LLM de vous montrer comment créer :** + +1. Un graphique en **points** (`geom_point()`) +2. Un graphique en **lignes** (`geom_line()`) +3. Un **boxplot** (`geom_boxplot()`) +4. Un **histogramme** (`geom_histogram()`) + +::: {.fragment} +**Testez chaque type avec des données adaptées.** + +Certains types nécessitent des données spécifiques ! +::: + +::: {.notes} +20 minutes. Découverte de la variété des géométries disponibles. +::: + +## Exercice 8 : Graphiques par catégorie {.smaller} + +**Challenge :** Créez un graphique des ventes coloré par vendeur. + +**Demandez au LLM :** + +> "Comment créer un graphique avec ggplot2 où chaque catégorie a une couleur différente ?" + +::: {.fragment} +Vous découvrirez : + +```{r} +#| eval: false +ggplot(ventes, aes(x = mois, y = montant, fill = vendeur)) + + geom_col(position = "dodge") + + labs(title = "Ventes par vendeur et par mois") +``` +::: + +::: {.fragment} +**Questions :** + +1. Que fait `position = "dodge"` ? +2. Que se passe-t-il sans ? +3. Comment faire un graphique empilé ? +::: + +::: {.notes} +20 minutes. Introduction aux graphiques multivariés. +::: + +# Fonctions de visualisation {background-color="#8B008B"} + +## Pourquoi créer des fonctions graphiques ? + +Si vous créez souvent le même type de graphique : + +::: {.incremental} +- Éviter la **répétition** du code +- Garantir la **cohérence** visuelle +- Faciliter la **maintenance** +- Permettre la **réutilisation** +::: + +## Exercice 9 : Première fonction graphique {.smaller} + +**Créez une fonction qui génère un graphique en barres standard :** + +```{r} +#| eval: false +graphique_barres <- function(donnees, colonne_x, colonne_y, titre) { + ggplot(donnees, aes(x = .data[[colonne_x]], y = .data[[colonne_y]])) + + geom_col(fill = "steelblue") + + labs(title = titre) + + theme_minimal() +} + +# Utilisation +graphique_barres(ventes, "mois", "montant", "Ventes mensuelles") +``` + +::: {.fragment} +**Demandez au LLM d'expliquer :** + +1. À quoi sert `.data[[...]]` ? +2. Comment passer des noms de colonnes comme paramètres ? +::: + +::: {.notes} +20 minutes. Introduction aux fonctions avec ggplot2. Concept avancé mais important. +::: + +## Exercice 10 : Fonction graphique avancée {.smaller} + +**Améliorez votre fonction avec plus d'options :** + +```{r} +#| eval: false +graphique_personnalise <- function(donnees, x, y, titre, + couleur = "steelblue", + type = "barres") { + # Créer le graphique de base + g <- ggplot(donnees, aes(x = .data[[x]], y = .data[[y]])) + + # Ajouter la géométrie selon le type + if (type == "barres") { + g <- g + geom_col(fill = couleur) + } else if (type == "points") { + g <- g + geom_point(color = couleur, size = 3) + } + + # Ajouter titre et thème + g <- g + labs(title = titre) + theme_minimal() + + return(g) +} +``` + +::: {.fragment} +**Testez avec différentes options !** +::: + +::: {.notes} +20 minutes. Fonction plus sophistiquée avec options et conditions. +::: + +# Mini-projet : Dashboard {background-color="#DC143C"} + +## Projet : Analyse de ventes complète {.smaller} + +**Objectif :** Créer un dashboard d'analyse avec 4 graphiques différents. + +**Données :** + +```{r} +#| eval: false +# Téléchargez le fichier ventes_annuelles.csv depuis Moodle +ventes_annuelles <- read.csv("ventes_annuelles.csv") +``` + +**Les 4 graphiques à créer :** + +1. Évolution des ventes mensuelles (ligne) +2. Ventes par vendeur (barres) +3. Distribution des montants (histogramme) +4. Comparaison par trimestre (boxplot) + +::: {.callout-note} +## Utilisez ggplot2 pour tous les graphiques +Personnalisez-les avec des couleurs et titres appropriés. +::: + +::: {.notes} +40 minutes. Projet de synthèse. Combine nettoyage, analyse et visualisation. +::: + +## Critères du mini-projet {.smaller} + +::: {.incremental} +- ✅ Les données sont **nettoyées** (casse, NA gérés) +- ✅ Les 4 graphiques sont **créés avec ggplot2** +- ✅ Chaque graphique a un **titre et des labels** appropriés +- ✅ Le code est **commenté** +- ✅ Une **fonction de visualisation** réutilisable est créée +::: + +::: {.fragment} +**Bonus :** + +- Créer un 5ème graphique original +- Utiliser des facettes (`facet_wrap()`) +- Ajouter des annotations sur les graphiques +- Sauvegarder les graphiques avec `ggsave()` +::: + +# Retour réflexif {background-color="#2F4F4F"} + +## Exercice réflexif : Journal de bord {.smaller} + +**Documentez dans votre journal :** + +1. **Nettoyage de données** : + - Quels problèmes avez-vous rencontrés ? + - Comment les avez-vous résolus ? + - Un prompt efficace pour le nettoyage + +2. **ggplot2** : + - Différences avec `plot()` de base + - Votre graphique préféré créé aujourd'hui + - Un concept difficile à comprendre + +3. **Fonctions graphiques** : + - Pourquoi créer des fonctions pour les graphiques ? + - Code de votre fonction réutilisable + +::: {.notes} +10 minutes. Moment de réflexion et documentation. +::: + +## Ce que vous avez appris aujourd'hui + +::: {.incremental} +✅ Nettoyer des données réelles avec incohérences +✅ Utiliser ggplot2 pour créer des graphiques professionnels +✅ Maîtriser différentes géométries (barres, points, lignes, boxplot) +✅ Personnaliser l'apparence des graphiques +✅ Créer des fonctions de visualisation réutilisables +✅ Combiner analyse et communication visuelle +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Fonctions clés de cette séance + +**Nettoyage :** + +- `tolower()`, `toupper()` : standardiser la casse +- `na.omit()` : supprimer les NA +- `unique()`, `table()` : explorer les valeurs + +**ggplot2 :** + +- `ggplot()` + `aes()` : base du graphique +- `geom_col()`, `geom_point()`, `geom_line()` : géométries +- `labs()` : titres et labels +- `theme_minimal()`, `theme_bw()` : thèmes + +## Pour aller plus loin + +::: {.incremental} +- **Explorez** d'autres géométries de ggplot2 +- **Pratiquez** avec vos propres données +- **Créez** une bibliothèque de fonctions graphiques +- **Consultez** la documentation : `?ggplot2` +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez le dashboard si besoin +2. **Mettez à jour votre journal** avec les détails de cette séance +3. Trouvez un jeu de données qui vous intéresse pour le projet de la séance 5 +4. Créez au moins 2 fonctions graphiques réutilisables +::: + +::: {.fragment} +**Prochaine séance :** Projet personnel intégré - vous allez mener une analyse complète en autonomie ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Le **nettoyage** des données est essentiel et prend du temps +- **ggplot2** permet de créer des graphiques professionnels de manière cohérente +- Les **fonctions graphiques** évitent la répétition et assurent la cohérence +- La **visualisation** est aussi importante que l'analyse +::: + +::: {.fragment} +**Bon courage et belles visualisations ! 📊** +::: \ No newline at end of file diff --git a/ECLibre/06Lecon5Projet.qmd b/ECLibre/06Lecon5Projet.qmd new file mode 100644 index 0000000..1e88ef7 --- /dev/null +++ b/ECLibre/06Lecon5Projet.qmd @@ -0,0 +1,504 @@ +--- +title: "Séance 5 : Projet personnel intégré" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon5.html + embed-resources: true + footer: "Séance 5 - Projet personnel intégré" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Présentation du projet** (15min) : Cadrage et attentes +- **Choix et préparation** (30min) : Sélection du dataset et définition des questions +- **Travail autonome supervisé** (120min) : Analyse libre avec consultations individuelles +- **Présentations courtes** (45min) : Partage des résultats (5min/étudiant) +::: + +::: {.fragment} +**Production attendue :** Analyse complète avec code, graphiques et interprétation +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Mener une analyse complète en autonomie +::: + +::: {.incremental} +- **Choisir** et cadrer un sujet d'analyse personnel +- **Appliquer** toutes les compétences acquises +- Travailler en **autonomie** avec le LLM comme assistant +- **Communiquer** ses résultats de manière claire +- **Recevoir** et donner du feedback constructif +::: + +# Présentation du projet {background-color="#2E8B57"} + +## Qu'est-ce qu'un projet intégré ? + +C'est une analyse complète qui combine **TOUT** ce que vous avez appris : + +::: {.incremental} +- ✅ Import et nettoyage de données +- ✅ Statistiques descriptives +- ✅ Fonctions personnalisées +- ✅ Conditions et boucles si nécessaire +- ✅ Visualisations avec ggplot2 +- ✅ Interprétation des résultats +- ✅ Utilisation efficace des LLMs +::: + +## Structure attendue + +Votre projet doit contenir : + +::: {.incremental} +1. **Introduction** : Quel sujet ? Quelles questions ? +2. **Données** : Source, description, nettoyage +3. **Analyse** : Statistiques, visualisations +4. **Fonctions** : Au moins 2 fonctions personnalisées +5. **Résultats** : Interprétation claire +6. **Code** : Commenté et organisé +::: + +## Critères d'évaluation {.smaller} + +::: {.incremental} +**Excellence technique (40%) :** + +- Code fonctionnel et robuste +- Nettoyage approprié des données +- Utilisation correcte des fonctions +- Visualisations claires + +**Analyse (30%) :** + +- Questions pertinentes +- Statistiques appropriées +- Interprétation correcte + +**Communication (20%) :** + +- Code commenté +- Présentation structurée +- Graphiques lisibles + +**Utilisation des LLMs (10%) :** + +- Prompts efficaces +- Validation critique des réponses +::: + +# Choix et cadrage {background-color="#4169E1"} + +## Étape 1 : Choisir un dataset + +::: {.callout-note} +## Sources de données possibles +::: + +::: {.incremental} +- **Données personnelles** : vos propres observations, sondages +- **Données publiques** : INSEE, data.gouv.fr, Kaggle +- **Données du cours** : datasets fournis sur Moodle +- **Données de votre domaine** : économie, psychologie, sport, santé +::: + +::: {.fragment} +::: {.callout-warning} +## Critères de choix +- Pas trop volumineux (< 10 000 lignes) +- Au moins 3-4 variables +- Vous intéresse vraiment ! +::: +::: + +## Exercice 1 : Exploration initiale {.smaller} + +**Une fois votre dataset choisi :** + +1. **Importez-le** dans R +2. **Explorez-le** : + +```{r} +#| eval: false +# Premières lignes +head(mes_donnees) + +# Structure +str(mes_donnees) + +# Résumé +summary(mes_donnees) + +# Dimensions +dim(mes_donnees) +``` + +3. **Identifiez** les problèmes potentiels (NA, types, incohérences) + +::: {.notes} +15 minutes. Les étudiants découvrent leurs données. +::: + +## Étape 2 : Définir ses questions + +**Avant d'analyser, définissez 2-3 questions claires.** + +::: {.fragment} +**Exemples de bonnes questions :** + +- "Quelle est l'évolution des ventes au fil du temps ?" +- "Y a-t-il une différence de salaire entre les groupes ?" +- "Quels facteurs influencent le plus la note finale ?" +::: + +::: {.fragment} +**Mauvaises questions (trop vagues) :** + +- "Qu'est-ce qu'il y a dans ces données ?" +- "Fais une analyse" +::: + +## Exercice 2 : Cadrage du projet {.smaller} + +**Remplissez ce cadre (écrivez-le !) :** + +``` +PROJET : [Titre court] + +DONNÉES : +- Source : +- Nombre de lignes : +- Variables principales : + +QUESTIONS : +1. +2. +3. + +ANALYSES PRÉVUES : +- Statistiques : +- Graphiques : +- Fonctions à créer : +``` + +::: {.fragment} +**Montrez votre cadre à l'enseignant avant de commencer !** +::: + +::: {.notes} +15 minutes. Validation du cadrage. Éviter que les étudiants se lancent sans direction. +::: + +# Travail autonome {background-color="#FF8C00"} + +## Phase de travail (2h) + +::: {.callout-tip} +## Vous êtes maintenant autonome ! +::: + +**Utilisez tout ce que vous avez appris :** + +- Les LLMs pour vous aider +- La documentation R +- Votre journal de bord +- Vos camarades +- L'enseignant (consultations individuelles) + +::: {.fragment} +::: {.callout-warning} +## Attention ! +- Testez votre code régulièrement +- Commentez au fur et à mesure +- Sauvegardez souvent +- Documentez vos prompts LLM +::: +::: + +## Checklist de progression {.smaller} + +::: {.nonincremental} +**Pendant votre travail, vérifiez que vous avez :** + +☐ Importé et vérifié les données +☐ Nettoyé les données (NA, types, casse) +☐ Calculé des statistiques descriptives +☐ Créé au moins 3 graphiques ggplot2 +☐ Écrit au moins 2 fonctions personnalisées +☐ Commenté votre code +☐ Répondu à vos questions initiales +☐ Testé que tout fonctionne + +::: + +## Stratégies pour avancer + +**Si vous êtes bloqué :** + +::: {.incremental} +1. **Décomposez** le problème en étapes plus petites +2. **Demandez au LLM** une étape à la fois +3. **Testez** chaque étape avant de passer à la suivante +4. **Consultez** votre journal des séances précédentes +5. **Demandez** de l'aide à un camarade ou l'enseignant +::: + +::: {.fragment} +**Si vous avancez vite :** + +- Créez des visualisations plus sophistiquées +- Ajoutez des fonctions bonus +- Explorez des analyses supplémentaires +- Aidez vos camarades +::: + +## Consultations individuelles + +::: {.callout-note} +## L'enseignant circule +::: + +Vous pouvez demander : + +- Validation de votre approche +- Aide sur un bug précis +- Conseils sur les visualisations +- Vérification de votre code + +::: {.fragment} +::: {.callout-tip} +## Préparez votre question +Avant d'appeler l'enseignant, préparez : + +- Ce que vous essayez de faire +- Ce que vous avez déjà essayé +- Le message d'erreur exact (si erreur) +::: +::: + +## Exemples de projets réussis {.smaller} + +**Pour vous inspirer :** + +::: {.incremental} +**Analyse de données sportives :** + +- Évolution des performances d'une équipe +- Comparaison entre joueurs +- Fonction : calculer et visualiser les statistiques d'un joueur + +**Analyse économique :** + +- Évolution du PIB par pays +- Comparaison de secteurs économiques +- Fonction : calculer la croissance sur différentes périodes + +**Données de santé :** + +- Relation entre facteurs et résultats de santé +- Distribution des variables +- Fonction : classifier les risques selon des critères + +**Analyse de sondage :** + +- Pourcentages par catégorie +- Comparaisons entre groupes +- Fonction : créer des graphiques standardisés +::: + +# Présentations {background-color="#8B008B"} + +## Format de présentation + +**5 minutes par personne** : + +::: {.incremental} +1. **Sujet et questions** (30 sec) : Quoi et pourquoi ? +2. **Données** (30 sec) : Source, nettoyage +3. **Résultats** (3 min) : Montrez 2-3 graphiques clés +4. **Fonctions créées** (1 min) : Vos outils personnalisés +5. **Questions** (30 sec) : Discussions avec les pairs +::: + +::: {.fragment} +::: {.callout-warning} +## Contrainte +Montrez votre code R en LIVE (pas de PowerPoint) ! +::: +::: + +## Exercice 3 : Préparer sa présentation {.smaller} + +**Dans les 10 dernières minutes de travail :** + +1. **Sélectionnez** vos 2-3 graphiques les plus importants +2. **Préparez** votre script pour montrer : + - L'import des données + - Un exemple de nettoyage + - Les graphiques principaux + - Une fonction en action +3. **Testez** que tout s'exécute sans erreur +4. **Notez** les points clés à mentionner + +::: {.fragment} +**Astuce :** Créez un script de présentation séparé avec juste l'essentiel +::: + +## Grille d'écoute {.smaller} + +**Pendant les présentations des autres, notez :** + +::: {.nonincremental} +- Une **approche intéressante** que vous pourriez réutiliser +- Une **visualisation** particulièrement réussie +- Une **question** ou suggestion constructive +- Un **problème** similaire à ce que vous avez rencontré +::: + +::: {.fragment} +::: {.callout-tip} +## Feedback constructif +Donnez des retours bienveillants et constructifs. Vous êtes tous en apprentissage ! +::: +::: + +## Célébration des réussites + +::: {.callout-note} +## Vous avez réussi votre premier projet complet ! +::: + +::: {.incremental} +**Réfléchissez :** + +- Qu'est-ce qui a été le plus difficile ? +- Qu'est-ce qui vous a le plus surpris ? +- Qu'est-ce qui vous a le plus appris ? +- Qu'est-ce qui vous a le plus plu ? +::: + +# Retour réflexif {background-color="#DC143C"} + +## Exercice réflexif : Journal de bord {.smaller} + +**Documentez en détail dans votre journal :** + +1. **Votre projet** : + - Sujet choisi et pourquoi + - Questions posées + - Résultats principaux + +2. **Défis techniques** : + - Problèmes rencontrés + - Solutions trouvées + - Rôle du LLM dans la résolution + +3. **Apprentissages** : + - Ce que vous maîtrisez maintenant + - Ce qui reste difficile + - Progression depuis la séance 1 + +4. **Prompts LLM** : + - Vos prompts les plus efficaces + - Erreurs du LLM et comment vous les avez corrigées + +::: {.notes} +15 minutes. Documentation importante de ce projet majeur. +::: + +## Auto-évaluation + +**Évaluez votre propre projet :** + +::: {.nonincremental} +| Critère | 🔴 Faible | 🟡 Moyen | 🟢 Bon | 🟢🟢 Excellent | +|---------|----------|---------|-------|--------------| +| Code fonctionnel | | | | | +| Nettoyage données | | | | | +| Qualité graphiques | | | | | +| Interprétation | | | | | +| Commentaires | | | | | +| Utilisation LLM | | | | | +::: + +::: {.fragment} +**Identifiez vos axes d'amélioration pour la suite du cours.** +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Ce que vous avez accompli + +::: {.incremental} +✅ Choisi et cadré un projet d'analyse personnalisé +✅ Mené une analyse complète en autonomie +✅ Créé des fonctions personnalisées et réutilisables +✅ Produit des visualisations professionnelles +✅ Communiqué vos résultats à vos pairs +✅ Utilisé les LLMs comme partenaires d'analyse +✅ Développé votre autonomie en programmation +::: + +::: {.fragment} +**🎉 Félicitations ! Vous êtes maintenant capables d'analyser des données en autonomie !** +::: + +## Compétences à ce stade + +**Vous savez maintenant :** + +::: {.incremental} +- Analyser des données de A à Z +- Choisir les bonnes analyses et visualisations +- Créer des fonctions adaptées à vos besoins +- Nettoyer et préparer des données réelles +- Interpréter et communiquer des résultats +- Utiliser les LLMs efficacement +- Débugger de manière autonome +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. **Finalisez votre projet** si besoin +2. **Mettez à jour votre journal** avec tous les détails +3. **Améliorez** un aspect de votre projet suite aux feedbacks +4. **Réfléchissez** : quelles parties de votre code pourraient être mieux organisées ? +::: + +::: {.fragment} +**Prochaine séance :** Organisation et modularité - structurer son code comme un professionnel ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Vous êtes **capables** d'analyser des données en autonomie +- Le **cadrage** initial est crucial pour la réussite +- Les **LLMs** sont des assistants, mais c'est **vous** qui dirigez +- **Tester** et **commenter** au fur et à mesure est essentiel +- Le **feedback** des pairs enrichit votre apprentissage +::: + +::: {.fragment} +**Bravo pour ce projet ! 🚀** +::: \ No newline at end of file diff --git a/ECLibre/07Lecon6Organisation.qmd b/ECLibre/07Lecon6Organisation.qmd new file mode 100644 index 0000000..019d20e --- /dev/null +++ b/ECLibre/07Lecon6Organisation.qmd @@ -0,0 +1,660 @@ +--- +title: "Séance 6 : Organisation et modularité" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon6.html + embed-resources: true + footer: "Séance 6 - Organisation et modularité" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur les projets +- **Refactoring collectif** (45min) : Organiser un long script +- **Packages et écosystème R** (60min) : dplyr, lubridate, stringr +- **Gestion des erreurs courantes** (45min) : Packages manquants, conflits +- **Mini-package personnel** (50min) : Organiser ses fonctions +::: + +::: {.fragment} +**Production attendue :** Code organisé en modules + maîtrise de 3 packages +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Structurer son code comme un professionnel +::: + +::: {.incremental} +- **Organiser** son code en modules logiques +- **Découvrir** l'écosystème des packages R +- **Maîtriser** dplyr pour manipuler les données +- **Gérer** les erreurs liées aux packages +- **Créer** sa propre bibliothèque de fonctions +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur vos projets + +::: {.incremental} +- Quels retours avez-vous reçus ? +- Qu'avez-vous amélioré dans votre projet ? +- Une difficulté commune que vous avez observée ? +::: + +## Le problème du code "spaghetti" + +**Observez ce type de code :** + +```{r} +#| eval: false +# 500 lignes de code dans un seul fichier... +donnees <- read.csv("data.csv") +donnees$nom <- tolower(donnees$nom) +# ... 50 lignes de nettoyage ... +moyenne1 <- mean(donnees$valeur1, na.rm = TRUE) +# ... 30 lignes de calculs ... +ggplot(donnees, aes(x = var1, y = var2)) + geom_point() +# ... encore 400 lignes ... +``` + +::: {.fragment} +::: {.callout-warning} +## Problèmes +- Difficile à lire +- Difficile à maintenir +- Impossible à réutiliser +- Difficile à débugger +::: +::: + +# Refactoring collectif {background-color="#4169E1"} + +## Qu'est-ce que le refactoring ? + +**Refactoring** = Réorganiser le code sans changer son comportement + +::: {.incremental} +**Objectifs :** + +- Améliorer la **lisibilité** +- Faciliter la **réutilisation** +- Simplifier la **maintenance** +- Réduire la **duplication** +::: + +## Exercice 1 : Analyser du code désordonné {.smaller} + +**Voici un script à améliorer :** + +```{r} +#| eval: false +d <- read.csv("ventes.csv") +d$nom <- tolower(d$nom) +d$date <- as.Date(d$date) +m <- mean(d$montant, na.rm = TRUE) +print(paste("Moyenne:", m)) +d2 <- d[d$montant > m, ] +plot(d2$date, d2$montant) +s <- sum(d$montant, na.rm = TRUE) +print(paste("Total:", s)) +d3 <- d[d$categorie == "A", ] +m2 <- mean(d3$montant, na.rm = TRUE) +``` + +**Demandez au LLM :** + +> "Quels sont les problèmes de ce code ? Comment pourrait-on l'améliorer ?" + +::: {.notes} +15 minutes. Discussion collective sur les problèmes. +::: + +## Principes d'organisation + +::: {.incremental} +1. **Un fichier = une responsabilité** + - `01_import_donnees.R` + - `02_nettoyage.R` + - `03_fonctions_analyse.R` + - `04_visualisation.R` + +2. **Des noms explicites** + - `calculer_moyenne_par_groupe()` ✅ + - `calc()` ❌ + +3. **Des fonctions courtes** + - Une fonction = une tâche + +4. **Des commentaires utiles** + - Expliquer le "pourquoi", pas le "quoi" +::: + +## Exercice 2 : Refactoring guidé {.smaller} + +**Transformons le code précédent ensemble :** + +**Étape 1 - Fonctions de nettoyage :** + +```{r} +#| eval: false +nettoyer_noms <- function(data) { + data$nom <- tolower(data$nom) + return(data) +} + +convertir_dates <- function(data, colonne_date) { + data[[colonne_date]] <- as.Date(data[[colonne_date]]) + return(data) +} +``` + +**Étape 2 - Fonctions d'analyse :** + +```{r} +#| eval: false +calculer_statistiques <- function(data, colonne) { + list( + moyenne = mean(data[[colonne]], na.rm = TRUE), + total = sum(data[[colonne]], na.rm = TRUE), + n = length(data[[colonne]]) + ) +} +``` + +::: {.notes} +20 minutes. Refactoring collectif guidé. +::: + +## Exercice 3 : Organisation en modules {.smaller} + +**Créez la structure suivante :** + +``` +mon_projet/ +├── donnees/ +│ └── ventes.csv +├── scripts/ +│ ├── 01_fonctions_nettoyage.R +│ ├── 02_fonctions_analyse.R +│ └── 03_fonctions_visualisation.R +└── analyse_principale.R +``` + +**Dans `analyse_principale.R` :** + +```{r} +#| eval: false +# Charger les fonctions +source("scripts/01_fonctions_nettoyage.R") +source("scripts/02_fonctions_analyse.R") +source("scripts/03_fonctions_visualisation.R") + +# Utiliser les fonctions +donnees <- read.csv("donnees/ventes.csv") +donnees <- nettoyer_noms(donnees) +stats <- calculer_statistiques(donnees, "montant") +``` + +::: {.notes} +20 minutes. Les étudiants créent leur première structure modulaire. +::: + +# Packages et écosystème R {background-color="#FF8C00"} + +## Qu'est-ce qu'un package ? + +Un **package** = Collection de fonctions réutilisables + +::: {.incremental} +**Avantages :** + +- Fonctions **testées** et **documentées** +- **Gain de temps** énorme +- **Communauté** active +- **Standards** professionnels +::: + +::: {.fragment} +**Exemples célèbres :** + +- `ggplot2` : graphiques (vous connaissez déjà !) +- `dplyr` : manipulation de données +- `tidyr` : restructuration de données +- `lubridate` : dates et heures +::: + +## Installer et charger un package + +**Installation (une seule fois) :** + +```{r} +#| eval: false +install.packages("dplyr") +``` + +**Chargement (à chaque session) :** + +```{r} +#| eval: false +library(dplyr) +``` + +::: {.fragment} +::: {.callout-note} +## Important +`install.packages()` : télécharge depuis internet +`library()` : active pour utilisation +::: +::: + +## Exercice 4 : Découvrir dplyr {.smaller} + +**dplyr simplifie la manipulation de données** + +**Demandez au LLM :** + +> "Explique-moi les principales fonctions de dplyr en R avec des exemples simples" + +::: {.fragment} +**Fonctions principales :** + +- `filter()` : filtrer les lignes +- `select()` : sélectionner les colonnes +- `mutate()` : créer/modifier des colonnes +- `summarise()` : calculer des résumés +- `group_by()` : grouper par catégorie +- `arrange()` : trier les lignes +::: + +::: {.fragment} +**Testez avec vos données !** +::: + +::: {.notes} +20 minutes. Première découverte de dplyr. +::: + +## Le pipe `%>%` (ou `|>`) + +**dplyr introduit le pipe pour chaîner les opérations :** + +```{r} +#| eval: false +# Ancienne méthode (difficile à lire) +resultat <- arrange( + summarise( + group_by( + filter(donnees, age > 18), + categorie + ), + moyenne = mean(valeur) + ), + moyenne +) + +# Avec le pipe (facile à lire) +resultat <- donnees %>% + filter(age > 18) %>% + group_by(categorie) %>% + summarise(moyenne = mean(valeur)) %>% + arrange(moyenne) +``` + +::: {.fragment} +**Le pipe se lit comme : "puis"** +::: + +## Exercice 5 : Pratiquer dplyr {.smaller} + +**Avec un dataset de ventes, utilisez dplyr pour :** + +```{r} +#| eval: false +library(dplyr) + +ventes %>% + filter(montant > 1000) %>% # Garder montants > 1000 + select(vendeur, montant, date) %>% # Sélectionner colonnes + mutate(montant_ttc = montant * 1.2) %>% # Ajouter TVA + group_by(vendeur) %>% # Grouper par vendeur + summarise( + total = sum(montant_ttc), + moyenne = mean(montant_ttc), + n_ventes = n() + ) %>% + arrange(desc(total)) # Trier par total décroissant +``` + +**Demandez au LLM d'expliquer chaque ligne si besoin !** + +::: {.notes} +20 minutes. Exercice pratique avec dplyr. +::: + +## Exercice 6 : Autres packages utiles {.smaller} + +**Découvrez d'autres packages :** + +**lubridate (dates) :** + +```{r} +#| eval: false +library(lubridate) + +date <- "2023-01-15" +d <- ymd(date) +year(d) # Extraire l'année +month(d) # Extraire le mois +wday(d, label = TRUE) # Jour de la semaine +``` + +**stringr (texte) :** + +```{r} +#| eval: false +library(stringr) + +texte <- " Bonjour " +str_trim(texte) # Enlever espaces +str_to_upper(texte) # Majuscules +str_detect(texte, "Bon") # Détecter motif +``` + +**Demandez au LLM des exemples pour chaque package !** + +::: {.notes} +20 minutes. Découverte d'autres packages utiles. +::: + +# Gestion des erreurs {background-color="#8B008B"} + +## Erreurs courantes avec les packages + +::: {.incremental} +**1. Package non installé :** + +``` +Error: could not find function "filter" +→ Avez-vous fait install.packages("dplyr") ? +``` + +**2. Package non chargé :** + +``` +Error: could not find function "filter" +→ Avez-vous fait library(dplyr) ? +``` + +**3. Conflits de noms :** + +``` +filter() existe dans dplyr ET dans stats +→ Utiliser dplyr::filter() pour être explicite +``` + +**4. Versions incompatibles :** + +``` +Le package nécessite R version 4.0 minimum +→ Mettre à jour R +``` +::: + +## Exercice 7 : Debugging de packages {.smaller} + +**Corrigez ces erreurs volontaires :** + +```{r} +#| eval: false +# Problème 1 +donnees %>% + filter(age > 18) +# Erreur: could not find function "%>%" + +# Problème 2 +library(dplyr) +select(iris, Species, Sepal.Length) +# Marche, mais warning sur conflit avec MASS + +# Problème 3 +install.packages("monpackageinexistant") +# Erreur: package not found +``` + +**Demandez au LLM de vous aider à comprendre et résoudre chaque erreur.** + +::: {.notes} +15 minutes. Exercice de debugging. +::: + +## Bonnes pratiques + +::: {.incremental} +**Au début de chaque script :** + +```{r} +#| eval: false +# Charger les packages nécessaires +library(dplyr) +library(ggplot2) +library(lubridate) + +# Vérifier la version R si besoin +if (getRversion() < "4.0.0") { + stop("Ce script nécessite R version 4.0 ou supérieure") +} +``` + +**En cas de conflit :** + +```{r} +#| eval: false +# Spécifier explicitement le package +dplyr::filter(donnees, age > 18) +stats::filter(serie_temporelle, filtre) +``` +::: + +# Mini-package personnel {background-color="#DC143C"} + +## Projet : Organiser vos fonctions + +**Objectif :** Créer une bibliothèque personnelle de fonctions réutilisables + +**Structure :** + +``` +ma_bibliotheque/ +├── nettoyage.R +├── analyse.R +├── visualisation.R +└── utils.R +``` + +## Exercice 8 : Créer sa bibliothèque {.smaller} + +**Dans `nettoyage.R` :** + +```{r} +#| eval: false +#' Standardiser les noms en minuscules +#' @param data Un dataframe +#' @param colonne Nom de la colonne à nettoyer +#' @return Le dataframe avec la colonne nettoyée +standardiser_noms <- function(data, colonne) { + data[[colonne]] <- tolower(data[[colonne]]) + return(data) +} + +#' Supprimer les lignes avec NA +supprimer_na <- function(data, colonnes = NULL) { + if (is.null(colonnes)) { + return(na.omit(data)) + } + data[complete.cases(data[, colonnes]), ] +} +``` + +**Créez au moins 3 fonctions dans chaque fichier !** + +::: {.notes} +30 minutes. Les étudiants organisent leurs fonctions. +::: + +## Documentation des fonctions + +**Utilisez les commentaires roxygen2 :** + +```{r} +#| eval: false +#' Titre court de la fonction +#' +#' Description détaillée de ce que fait la fonction. +#' +#' @param parametre1 Description du premier paramètre +#' @param parametre2 Description du second paramètre +#' @return Description de ce que retourne la fonction +#' @examples +#' ma_fonction(donnees, "colonne") +ma_fonction <- function(parametre1, parametre2) { + # Code ici +} +``` + +::: {.fragment} +**Demandez au LLM de vous aider à documenter vos fonctions !** +::: + +## Exercice 9 : Utiliser sa bibliothèque {.smaller} + +**Créez un script principal qui utilise votre bibliothèque :** + +```{r} +#| eval: false +# Charger toutes vos fonctions +source("ma_bibliotheque/nettoyage.R") +source("ma_bibliotheque/analyse.R") +source("ma_bibliotheque/visualisation.R") + +# Utiliser vos fonctions +donnees <- read.csv("data.csv") +donnees <- standardiser_noms(donnees, "nom") +donnees <- supprimer_na(donnees, c("age", "salaire")) + +stats <- calculer_statistiques_complete(donnees) +plot_distribution(donnees, "salaire") +``` + +**Testez que tout fonctionne !** + +::: {.notes} +20 minutes. Test d'intégration. +::: + +# Retour réflexif {background-color="#2F4F4F"} + +## Exercice réflexif : Journal de bord {.smaller} + +**Documentez :** + +1. **Refactoring** : + - Avant/après : montrez un exemple de code que vous avez amélioré + - Qu'est-ce qui rend le code "après" meilleur ? + +2. **Packages** : + - Les 3 packages découverts aujourd'hui + - Fonction la plus utile de chaque package + - Une erreur de package que vous avez résolue + +3. **Organisation** : + - Structure de votre bibliothèque personnelle + - Vos fonctions les plus réutilisables + - Comment cette organisation vous aidera + +::: {.notes} +15 minutes. Documentation des apprentissages. +::: + +## Ce que vous avez appris + +::: {.incremental} +✅ Organiser son code en modules logiques +✅ Créer et documenter des fonctions réutilisables +✅ Utiliser dplyr pour manipuler les données +✅ Découvrir l'écosystème des packages R +✅ Gérer les erreurs liées aux packages +✅ Créer sa propre bibliothèque de fonctions +✅ Adopter les bonnes pratiques professionnelles +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Packages clés découverts + +**dplyr :** + +- `filter()`, `select()`, `mutate()`, `summarise()`, `group_by()` +- Le pipe `%>%` (ou `|>`) + +**lubridate :** + +- `ymd()`, `year()`, `month()`, `wday()` + +**stringr :** + +- `str_trim()`, `str_to_upper()`, `str_detect()` + +## Pour aller plus loin + +::: {.incremental} +- **Explorez** d'autres packages du tidyverse +- **Organisez** vos anciens projets avec cette nouvelle structure +- **Documentez** systématiquement vos fonctions +- **Partagez** vos fonctions avec vos camarades +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Réorganisez un de vos anciens projets avec la structure modulaire +2. Créez au moins 5 fonctions documentées dans votre bibliothèque +3. Pratiquez dplyr avec vos propres données +4. **Mettez à jour votre journal** avec tous les détails +::: + +::: {.fragment} +**Prochaine séance :** Automatisation et rapports - traiter plusieurs fichiers et créer des rapports reproductibles ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Le **code organisé** est plus facile à maintenir et réutiliser +- Les **packages** vous font gagner un temps précieux +- **dplyr** est essentiel pour manipuler des données +- **Documenter** ses fonctions est une bonne pratique +- La **modularité** est la clé du code professionnel +::: + +::: {.fragment} +**Bon courage pour l'organisation ! 📚** +::: \ No newline at end of file diff --git a/ECLibre/08Lecon7Automatisation.qmd b/ECLibre/08Lecon7Automatisation.qmd new file mode 100644 index 0000000..e48b770 --- /dev/null +++ b/ECLibre/08Lecon7Automatisation.qmd @@ -0,0 +1,733 @@ +--- +title: "Séance 7 : Automatisation et rapports" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon7.html + embed-resources: true + footer: "Séance 7 - Automatisation et rapports" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur l'organisation du code +- **Traitement par lots** (60min) : Analyser plusieurs fichiers automatiquement +- **Introduction à R Markdown** (60min) : Mélanger code, texte et résultats +- **Rapport paramétré** (65min) : Créer un template d'analyse réutilisable +::: + +::: {.fragment} +**Production attendue :** Rapport automatisé fonctionnel au format PDF/HTML +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Automatiser pour gagner du temps +::: + +::: {.incremental} +- **Automatiser** le traitement de plusieurs fichiers +- **Créer** des rapports reproductibles +- **Maîtriser** R Markdown pour mélanger code et texte +- **Paramétrer** ses analyses pour la réutilisation +- **Générer** des documents professionnels +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur l'organisation + +::: {.incremental} +- Comment avez-vous organisé votre code ? +- Quelles difficultés avec les packages ? +- Une fonction utile que vous avez créée ? +::: + +## Le défi de l'échelle + +**Situation réelle :** + +::: {.fragment} +Vous avez analysé les ventes de janvier... +::: + +::: {.fragment} +Maintenant on vous demande d'analyser janvier, février, mars, avril, mai, juin... 📊 +::: + +::: {.fragment} +::: {.callout-warning} +## Problème +Copier-coller votre code 12 fois ? Non ! Il faut **automatiser**. +::: +::: + +# Traitement par lots {background-color="#4169E1"} + +## Principe de l'automatisation + +**Au lieu de :** + +```{r} +#| eval: false +ventes_jan <- read.csv("ventes_janvier.csv") +analyse_jan <- analyser(ventes_jan) + +ventes_fev <- read.csv("ventes_fevrier.csv") +analyse_fev <- analyser(ventes_fev) + +# ... répéter 10 fois ... +``` + +**On fait :** + +```{r} +#| eval: false +fichiers <- list.files(pattern = ".csv") + +for (fichier in fichiers) { + donnees <- read.csv(fichier) + analyse <- analyser(donnees) + sauvegarder_resultat(analyse, fichier) +} +``` + +## Exercice 1 : Lister des fichiers {.smaller} + +**Demandez au LLM :** + +> "Comment lister tous les fichiers CSV d'un dossier en R ?" + +::: {.fragment} +Vous découvrirez : + +```{r} +#| eval: false +# Lister tous les fichiers CSV du dossier courant +fichiers <- list.files(pattern = "\\.csv$") + +# Lister avec le chemin complet +fichiers <- list.files(path = "donnees/", pattern = "\\.csv$", + full.names = TRUE) + +# Voir les fichiers +print(fichiers) +``` +::: + +::: {.fragment} +**Testez avec vos propres fichiers !** +::: + +::: {.notes} +15 minutes. Première étape de l'automatisation. +::: + +## Exercice 2 : Boucle sur des fichiers {.smaller} + +**Créez un script qui traite plusieurs fichiers :** + +```{r} +#| eval: false +# Lister les fichiers +fichiers <- list.files(path = "donnees/", pattern = "\\.csv$", + full.names = TRUE) + +# Créer une liste pour stocker les résultats +resultats <- list() + +# Boucle sur chaque fichier +for (fichier in fichiers) { + # Lire le fichier + donnees <- read.csv(fichier) + + # Calculer des statistiques + stats <- data.frame( + fichier = basename(fichier), + n_lignes = nrow(donnees), + moyenne = mean(donnees$valeur, na.rm = TRUE) + ) + + # Stocker le résultat + resultats[[fichier]] <- stats +} + +# Combiner tous les résultats +resultats_final <- do.call(rbind, resultats) +``` + +::: {.notes} +20 minutes. Pattern essentiel pour l'automatisation. +::: + +## Exercice 3 : Fonction d'analyse par lots {.smaller} + +**Créez une fonction réutilisable :** + +```{r} +#| eval: false +analyser_dossier <- function(chemin, pattern = "\\.csv$") { + # Lister les fichiers + fichiers <- list.files(path = chemin, pattern = pattern, + full.names = TRUE) + + if (length(fichiers) == 0) { + stop("Aucun fichier trouvé !") + } + + # Analyser chaque fichier + resultats <- lapply(fichiers, function(f) { + donnees <- read.csv(f) + data.frame( + fichier = basename(f), + n_lignes = nrow(donnees), + n_colonnes = ncol(donnees), + moyenne_valeur = mean(donnees$valeur, na.rm = TRUE) + ) + }) + + # Combiner et retourner + do.call(rbind, resultats) +} + +# Utilisation +resultats <- analyser_dossier("donnees/ventes/") +``` + +::: {.notes} +25 minutes. Fonction professionnelle d'automatisation. +::: + +## Gestion des erreurs dans les boucles + +**Problème :** Un fichier corrompu plante tout ! + +```{r} +#| eval: false +# Mauvais : tout plante au premier problème +for (fichier in fichiers) { + donnees <- read.csv(fichier) # Erreur ici = tout s'arrête + analyser(donnees) +} + +# Bon : gérer les erreurs +for (fichier in fichiers) { + resultat <- tryCatch({ + donnees <- read.csv(fichier) + analyser(donnees) + }, error = function(e) { + message("Erreur avec ", fichier, ": ", e$message) + NULL # Retourner NULL en cas d'erreur + }) +} +``` + +::: {.fragment} +**Demandez au LLM d'expliquer `tryCatch()` !** +::: + +# Introduction à R Markdown {background-color="#FF8C00"} + +## Qu'est-ce que R Markdown ? + +**R Markdown** permet de créer des documents qui mélangent : + +::: {.incremental} +- Du **texte** (explications, interprétations) +- Du **code R** (analyses) +- Des **résultats** (tableaux, graphiques) +- Des **formules** mathématiques +::: + +::: {.fragment} +**Formats de sortie :** + +- PDF, HTML, Word +- Présentations (comme ce cours !) +- Sites web, livres +::: + +## Pourquoi R Markdown ? + +::: {.incremental} +**Avantages :** + +- **Reproductibilité** : tout est dans un seul fichier +- **Cohérence** : résultats toujours à jour avec le code +- **Communication** : rapports professionnels +- **Gain de temps** : pas de copier-coller de résultats +::: + +::: {.fragment} +::: {.callout-note} +## Important +Si vos données changent, votre rapport se met à jour automatiquement ! +::: +::: + +## Structure d'un document R Markdown {.smaller} + +**Un fichier `.Rmd` contient :** + +````markdown +--- +title: "Mon Rapport" +author: "Votre Nom" +date: "2025-01-15" +output: html_document +--- + +# Introduction + +Ceci est du texte normal. + +```{{r}} +# Ceci est du code R +donnees <- read.csv("data.csv") +mean(donnees$valeur) +``` + +## Résultats + +Le graphique ci-dessous montre... + +```{{r}} +plot(donnees$x, donnees$y) +``` +```` + +## Exercice 4 : Premier document R Markdown {.smaller} + +**Créez un nouveau fichier R Markdown :** + +1. Dans RStudio : File > New File > R Markdown +2. Donnez un titre et choisissez HTML +3. Cliquez sur "Knit" pour générer le document + +::: {.fragment} +**Observez :** + +- L'en-tête YAML (entre les `---`) +- Les blocs de code R (entre les ` ```{r} ` ) +- Le texte Markdown +- Le résultat généré +::: + +::: {.fragment} +**Demandez au LLM :** + +> "Explique-moi la syntaxe de base de Markdown (titres, listes, gras, italique)" +::: + +::: {.notes} +20 minutes. Première découverte de R Markdown. +::: + +## Options des blocs de code {.smaller} + +**On peut contrôler ce qui apparaît dans le rapport :** + +````markdown +```{{r, echo=TRUE, eval=TRUE}} +# echo=TRUE : montrer le code +# eval=TRUE : exécuter le code +x <- 1:10 +mean(x) +``` + +```{{r, echo=FALSE, eval=TRUE}} +# echo=FALSE : cacher le code, montrer seulement le résultat +plot(x, x^2) +``` + +```{{r, eval=FALSE}} +# eval=FALSE : montrer le code mais ne pas l'exécuter +# Utile pour montrer des exemples +install.packages("monpackage") +``` +```` + +::: {.fragment} +**Autres options utiles :** + +- `message=FALSE` : cacher les messages +- `warning=FALSE` : cacher les avertissements +- `fig.width=8, fig.height=5` : taille des graphiques +::: + +## Exercice 5 : Rapport d'analyse simple {.smaller} + +**Créez un rapport R Markdown qui :** + +1. Importe un jeu de données +2. Affiche les premières lignes (avec `head()`) +3. Calcule des statistiques (moyenne, médiane, etc.) +4. Crée 2 graphiques +5. Interprète les résultats en texte + +**Structure suggérée :** + +````markdown +# Introduction +Description du dataset... + +# Exploration des données +```{{r}} +donnees <- read.csv("data.csv") +head(donnees) +summary(donnees) +``` + +# Analyse +```{{r, echo=FALSE}} +# Graphiques sans montrer le code +``` + +# Conclusion +Les résultats montrent que... +```` + +::: {.notes} +30 minutes. Premier rapport complet. +::: + +## Markdown pour le formatage {.smaller} + +**Syntaxe de base :** + +```markdown +# Titre niveau 1 +## Titre niveau 2 +### Titre niveau 3 + +**Texte en gras** +*Texte en italique* + +- Liste à puces +- Deuxième élément + +1. Liste numérotée +2. Deuxième élément + +[Lien](https://www.example.com) + +![Image](chemin/vers/image.png) +``` + +::: {.fragment} +**Demandez au LLM de vous montrer plus d'options de formatage !** +::: + +# Rapport paramétré {background-color="#8B008B"} + +## Pourquoi paramétrer ? + +**Problème :** Vous voulez le même rapport pour différents datasets + +**Solution :** Créer un template paramétrable + +```markdown +--- +title: "Rapport de ventes" +params: + fichier: "ventes_janvier.csv" + seuil: 1000 +--- + +```{{r}} +donnees <- read.csv(params$fichier) +ventes_importantes <- donnees[donnees$montant > params$seuil, ] +``` +``` + +## Exercice 6 : Premier rapport paramétré {.smaller} + +**Créez un rapport avec paramètres :** + +````{verbatim} +--- +title: "Analyse automatisée" +params: + dataset: "data.csv" + variable: "valeur" + titre_graphique: "Distribution des valeurs" +output: html_document +--- + +# Analyse de `r params$variable` + +```{r} +donnees <- read.csv(params$dataset) +variable_data <- donnees[[params$variable]] + +# Statistiques +cat("Moyenne:", mean(variable_data, na.rm = TRUE), "\n") +cat("Médiane:", median(variable_data, na.rm = TRUE), "\n") + +# Graphique +hist(variable_data, main = params$titre_graphique) +``` +```` + +::: {.notes} +25 minutes. Introduction aux paramètres. +::: + +## Générer des rapports par programme {.smaller} + +**Vous pouvez générer des rapports depuis R :** + +```{r} +#| eval: false +library(rmarkdown) + +# Générer un rapport avec des paramètres spécifiques +render("template.Rmd", + params = list( + dataset = "ventes_janvier.csv", + variable = "montant", + titre_graphique = "Ventes de janvier" + ), + output_file = "rapport_janvier.html") + +# Boucle pour générer plusieurs rapports +fichiers <- c("ventes_janvier.csv", "ventes_fevrier.csv", "ventes_mars.csv") + +for (f in fichiers) { + mois <- tools::file_path_sans_ext(basename(f)) + + render("template.Rmd", + params = list( + dataset = f, + variable = "montant", + titre_graphique = paste("Ventes de", mois) + ), + output_file = paste0("rapport_", mois, ".html")) +} +``` + +::: {.notes} +20 minutes. Automatisation complète. +::: + +## Exercice 7 : Fonction de génération de rapport {.smaller} + +**Créez une fonction qui génère des rapports automatiquement :** + +```{r} +#| eval: false +generer_rapport <- function(fichier_donnees, output_dir = "rapports/") { + # Extraire le nom du fichier sans extension + nom_base <- tools::file_path_sans_ext(basename(fichier_donnees)) + + # Créer le dossier de sortie si nécessaire + if (!dir.exists(output_dir)) { + dir.create(output_dir, recursive = TRUE) + } + + # Générer le rapport + output_file <- file.path(output_dir, paste0("rapport_", nom_base, ".html")) + + rmarkdown::render( + "template_analyse.Rmd", + params = list( + dataset = fichier_donnees, + titre = paste("Analyse de", nom_base) + ), + output_file = output_file + ) + + message("Rapport généré : ", output_file) + return(output_file) +} + +# Utilisation +fichiers <- list.files("donnees/", pattern = "\\.csv$", full.names = TRUE) +rapports <- lapply(fichiers, generer_rapport) +``` + +::: {.notes} +30 minutes. Fonction professionnelle de génération de rapports. +::: + +## Formats de sortie multiples + +**R Markdown peut générer différents formats :** + +````markdown +--- +title: "Mon Rapport" +output: + html_document: + toc: true + toc_float: true + pdf_document: + toc: true + word_document: default +--- +```` + +::: {.fragment} +**Pour générer un format spécifique :** + +```{r} +#| eval: false +render("rapport.Rmd", output_format = "pdf_document") +``` +::: + +# Mini-projet : Système de rapports {background-color="#DC143C"} + +## Projet final : Rapports automatisés {.smaller} + +**Objectif :** Créer un système complet de génération de rapports + +**Spécifications :** + +1. Un **template R Markdown** paramétrable +2. Une **fonction** qui génère des rapports pour plusieurs fichiers +3. Les rapports doivent inclure : + - Import et nettoyage automatique + - Statistiques descriptives + - Au moins 3 graphiques + - Interprétation textuelle +4. Gestion des erreurs (fichiers manquants, colonnes manquantes) +5. Génération en HTML + +::: {.callout-note} +## Utilisez tout ce que vous avez appris +Fonctions, dplyr, ggplot2, gestion d'erreurs, R Markdown ! +::: + +::: {.notes} +65 minutes. Projet de synthèse final. +::: + +## Critères du projet {.smaller} + +::: {.incremental} +- ✅ Template R Markdown **paramétrable** et réutilisable +- ✅ Fonction de génération **robuste** (gère les erreurs) +- ✅ Rapports **complets** (stats + graphiques + texte) +- ✅ Code **commenté** et **organisé** +- ✅ **Fonctionne** avec différents fichiers de données +::: + +::: {.fragment} +**Bonus :** + +- Génération automatique d'un index de tous les rapports +- Graphiques interactifs avec `plotly` +- Rapport au format PDF +- Envoi automatique par email (avancé !) +::: + +# Retour réflexif {background-color="#2F4F4F"} + +## Exercice réflexif : Journal de bord {.smaller} + +**Documentez :** + +1. **Automatisation** : + - Comment automatiser un traitement répétitif ? + - Votre fonction d'analyse par lots + - Une erreur que vous avez gérée avec `tryCatch()` + +2. **R Markdown** : + - Différences avec un script R normal + - Avantages pour vos analyses + - Options de blocs de code les plus utiles + +3. **Rapports paramétrés** : + - Votre template réutilisable + - Comment vous allez l'utiliser à l'avenir + - Difficultés rencontrées et solutions + +::: {.notes} +15 minutes. Documentation des apprentissages avancés. +::: + +## Ce que vous avez accompli + +::: {.incremental} +✅ Automatiser le traitement de plusieurs fichiers +✅ Créer des rapports reproductibles avec R Markdown +✅ Paramétrer des analyses pour la réutilisation +✅ Générer des documents professionnels automatiquement +✅ Gérer les erreurs dans les processus automatisés +✅ Combiner toutes vos compétences en R +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Concepts clés de la séance + +**Automatisation :** + +- `list.files()` : lister des fichiers +- Boucles `for` et `lapply()` sur plusieurs fichiers +- `tryCatch()` : gestion des erreurs + +**R Markdown :** + +- Structure : YAML + Markdown + code R +- Options de blocs : `echo`, `eval`, `message`, `warning` +- `render()` : générer des rapports par programme + +**Paramètres :** + +- `params` dans le YAML +- Accès avec `params$nom_parametre` + +## Pour aller plus loin + +::: {.incremental} +- **Explorez** d'autres formats de sortie (PDF, Word, slides) +- **Créez** une bibliothèque de templates pour différents types d'analyses +- **Automatisez** la génération régulière de rapports (tâches planifiées) +- **Partagez** vos templates avec vos collègues +::: + +## Préparation séance finale + +::: {.callout-note} +## Devoirs + +1. Finalisez votre système de rapports automatisés +2. Testez-le avec au moins 3 fichiers différents +3. **Mettez à jour votre journal** en détail +4. Préparez-vous pour le projet collaboratif final +5. Réfléchissez aux bonnes pratiques pour travailler en équipe sur du code +::: + +::: {.fragment} +**Séance finale :** Projet collaboratif - intégrer vos compétences en équipe ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- **Automatiser** évite la répétition et les erreurs +- **R Markdown** garantit la reproductibilité +- Les **paramètres** rendent vos analyses réutilisables +- La **gestion d'erreurs** est essentielle en production +- Vous êtes maintenant capables de créer des **systèmes professionnels** ! +::: + +::: {.fragment} +**Bravo pour ces compétences avancées ! 🎓** +::: \ No newline at end of file diff --git a/ECLibre/09Lecon8Collaboratif.qmd b/ECLibre/09Lecon8Collaboratif.qmd new file mode 100644 index 0000000..69a6481 --- /dev/null +++ b/ECLibre/09Lecon8Collaboratif.qmd @@ -0,0 +1,825 @@ +--- +title: "Séance 8 : Projet collaboratif final" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon8.html + embed-resources: true + footer: "Séance 8 - Projet collaboratif final" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Présentation du projet collaboratif** (15min) : Organisation et objectifs +- **Constitution des équipes et répartition** (30min) : Former les groupes, assigner les angles d'analyse +- **Code review croisé** (45min) : Analyser et améliorer le code d'une autre équipe +- **Travail collaboratif** (90min) : Développement des analyses en équipe +- **Intégration collaborative** (30min) : Faire fonctionner ensemble les analyses +- **Présentation finale** (30min) : Synthèse collective des résultats +::: + +::: {.fragment} +**Production attendue :** Analyse collaborative intégrée + code review documenté +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Collaborer comme des professionnels +::: + +::: {.incremental} +- **Travailler en équipe** sur un projet d'analyse +- **Communiquer** efficacement sur le code +- **Intégrer** différentes analyses +- **Réviser** le code des autres (code review) +- **Appliquer** toutes les bonnes pratiques apprises +- **Présenter** des résultats de manière professionnelle +::: + +# Présentation du projet {background-color="#2E8B57"} + +## Le défi collaboratif + +**Situation réelle :** + +Une organisation vous confie un grand dataset et vous demande une analyse complète sous différents angles. + +::: {.fragment} +**4 équipes, 1 dataset, 4 perspectives complémentaires** +::: + +::: {.fragment} +::: {.callout-note} +## Objectif final +Produire une analyse intégrée qui combine les 4 perspectives pour une vision complète. +::: +::: + +## Structure du projet + +**Le dataset commun :** Données COVID, économiques, ou climatiques (fourni sur Moodle) + +**4 équipes, 4 angles d'analyse :** + +::: {.incremental} +1. **Équipe 1 - Évolution temporelle** : Comment les variables évoluent dans le temps ? +2. **Équipe 2 - Comparaisons géographiques** : Quelles différences entre régions/pays ? +3. **Équipe 3 - Facteurs socio-économiques** : Quels facteurs influencent les résultats ? +4. **Équipe 4 - Patterns et tendances** : Quels patterns émergent ? Prédictions simples ? +::: + +## Livrables par équipe {.smaller} + +**Chaque équipe doit produire :** + +::: {.incremental} +1. **Code R modulaire** (fichiers séparés) + - `fonctions_equipe_X.R` : vos fonctions + - `analyse_equipe_X.R` : script principal + - `README_equipe_X.md` : documentation + +2. **Rapport d'analyse** (R Markdown → HTML) + - Introduction et questions + - Méthodologie + - Résultats (graphiques + tableaux) + - Interprétation + - Conclusion + +3. **Présentation orale** (5 min) + - Résultats clés + - Contribution à la vision globale +::: + +## Livrable collectif final + +**Toutes les équipes ensemble produiront :** + +::: {.incremental} +- **Synthèse intégrée** : document combinant les 4 analyses +- **Code unifié** : fonctions compatibles entre équipes +- **Recommandations communes** : conclusions tirées de l'analyse complète +- **Présentation collective** : vision d'ensemble +::: + +## Critères d'évaluation {.smaller} + +**Note d'équipe (60%) :** + +- Qualité technique du code +- Pertinence de l'analyse +- Clarté du rapport +- Qualité de la présentation + +**Note individuelle (40%) :** + +- Contribution identifiable (commits, fonctions créées) +- Qualité du code review +- Participation active +- Collaboration avec les autres équipes + +::: {.fragment} +::: {.callout-tip} +## Tous ensemble ! +Le succès du projet dépend de la collaboration entre les équipes ! +::: +::: + +# Constitution des équipes {background-color="#4169E1"} + +## Formation des équipes + +**L'enseignant forme 4 équipes de 4-5 personnes** + +::: {.incremental} +**Critères de formation :** + +- Diversité des niveaux +- Complémentarité des compétences +- Mixité si possible +::: + +::: {.fragment} +**Chaque équipe se voit assigner un angle d'analyse** +::: + +## Exercice 1 : Organisation interne {.smaller} + +**Dans chaque équipe (15 min) :** + +1. **Désignez un coordinateur** (interface avec les autres équipes) +2. **Répartissez les rôles** : + - Responsable nettoyage des données + - Responsable analyses statistiques + - Responsable visualisations + - Responsable documentation + +3. **Définissez 3 questions précises** liées à votre angle d'analyse + +4. **Planifiez votre travail** : + - Quelles fonctions créer ? + - Quelle structure de code ? + - Comment vous répartir le travail ? + +::: {.notes} +15 minutes. Chaque équipe s'organise. +::: + +## Exercice 2 : Charte de collaboration {.smaller} + +**Chaque équipe définit sa charte :** + +```markdown +CHARTE D'ÉQUIPE X + +OBJECTIF : [Angle d'analyse] + +QUESTIONS À RÉPONDRE : +1. +2. +3. + +RÉPARTITION DES TÂCHES : +- Membre A : [responsabilité] +- Membre B : [responsabilité] +- ... + +CONVENTIONS DE CODE : +- Nommage des fonctions : equipe_X_nom_fonction() +- Nommage des variables : snake_case +- Commentaires : en français + +COMMUNICATION : +- Coordination : [nom du coordinateur] +- Fréquence des points : toutes les 30 minutes +``` + +::: {.notes} +15 minutes. Établir les règles de collaboration. +::: + +# Code Review Croisé {background-color="#FF8C00"} + +## Qu'est-ce qu'un code review ? + +**Code review** = Relecture critique du code par les pairs + +::: {.incremental} +**Objectifs :** + +- Trouver des **bugs** potentiels +- Améliorer la **lisibilité** +- Partager les **bonnes pratiques** +- Apprendre des **autres** +::: + +::: {.fragment} +::: {.callout-note} +## Dans l'industrie +Le code review est une pratique standard dans toutes les entreprises tech ! +::: +::: + +## Que regarder dans un code review ? + +::: {.incremental} +**Fonctionnalité :** + +- Le code fait-il ce qu'il est censé faire ? +- Gère-t-il les cas d'erreur ? + +**Lisibilité :** + +- Les noms de variables/fonctions sont-ils clairs ? +- Le code est-il bien commenté ? +- La structure est-elle logique ? + +**Efficacité :** + +- Y a-t-il des répétitions inutiles ? +- Les calculs sont-ils optimisés ? +- Les fonctions sont-elles réutilisables ? +::: + +## Exercice 3 : Code review d'une autre équipe {.smaller} + +**Organisation :** + +- Équipe 1 ↔ Équipe 2 +- Équipe 3 ↔ Équipe 4 + +**Chaque équipe examine le code d'une autre équipe (provenant d'un projet précédent)** + +**Grille de review :** + +```markdown +CODE REVIEW - Équipe X par Équipe Y + +POINTS POSITIFS : +- [Ce qui est bien fait] + +PROBLÈMES IDENTIFIÉS : +- [Bugs, erreurs logiques] + +SUGGESTIONS D'AMÉLIORATION : +- [Comment améliorer le code] + +CODE EXEMPLAIRE : +- [Un bout de code particulièrement bon] + +NOTE GLOBALE : [Sur 10] +``` + +::: {.notes} +45 minutes. Code review sérieux et constructif. +::: + +## Donner du feedback constructif + +::: {.callout-tip} +## Règles d'or du code review +::: + +::: {.incremental} +**À FAIRE ✅ :** + +- Être spécifique : "Cette boucle pourrait être remplacée par `lapply()`" +- Être constructif : "Et si on ajoutait une vérification ici ?" +- Reconnaître ce qui est bon : "Excellente documentation !" +- Suggérer, ne pas imposer : "Une alternative serait..." + +**À ÉVITER ❌ :** + +- Critiquer la personne : "Tu ne sais pas coder" +- Être vague : "C'est mauvais" +- Imposer son style : "Je fais toujours comme ça" +::: + +# Travail Collaboratif {background-color="#8B008B"} + +## Phase de développement (90 min) + +**Chaque équipe travaille sur son analyse :** + +::: {.incremental} +1. **Import et nettoyage** des données (commun à toutes les équipes) +2. **Analyses spécifiques** à votre angle +3. **Création de fonctions** réutilisables +4. **Visualisations** claires et informatives +5. **Rédaction du rapport** R Markdown +::: + +::: {.fragment} +::: {.callout-warning} +## Attention ! +Vos fonctions doivent être **compatibles** avec celles des autres équipes ! +::: +::: + +## Conventions entre équipes + +**Toutes les équipes doivent se mettre d'accord sur :** + +::: {.incremental} +**Noms des objets principaux :** + +```{r} +#| eval: false +donnees_brutes # Dataset original +donnees_propres # Dataset nettoyé +resultats_equipe_X # Résultats de chaque équipe +``` + +**Structure des fonctions :** + +```{r} +#| eval: false +# Chaque équipe préfixe ses fonctions +equipe1_analyser_temporel() +equipe2_analyser_geographique() +equipe3_analyser_facteurs() +equipe4_analyser_patterns() +``` + +**Format des sorties :** + +- Toutes les fonctions retournent des data.frames +- Même structure : colonnes standardisées +::: + +## Exercice 4 : Réunion inter-équipes {.smaller} + +**Les 4 coordinateurs se réunissent (10 min) pour :** + +1. S'accorder sur les **conventions de nommage** +2. Définir la **structure commune** des données nettoyées +3. Planifier l'**intégration finale** +4. Identifier les **dépendances** entre équipes + +**Résultat : Un document de conventions partagé** + +```markdown +CONVENTIONS INTER-ÉQUIPES + +OBJETS COMMUNS : +- donnees_brutes : dataset original +- donnees_propres : dataset nettoyé (structure : ...) + +PRÉFIXES DE FONCTIONS : +- Équipe 1 : e1_ +- Équipe 2 : e2_ +- Équipe 3 : e3_ +- Équipe 4 : e4_ + +FORMAT DES SORTIES : +Toutes les fonctions d'analyse retournent un data.frame avec : +- variable, valeur, interpretation +``` + +::: {.notes} +10 minutes. Coordination essentielle entre équipes. +::: + +## Checkpoints intermédiaires + +**Après 30 minutes :** + +- Chaque équipe présente son avancement (2 min/équipe) +- Identification des blocages +- Ajustements si nécessaire + +**Après 60 minutes :** + +- Vérification de la compatibilité du code +- Premiers tests d'intégration +- Corrections des incompatibilités + +## Consultations avec l'enseignant + +**L'enseignant circule pour :** + +- Débloquer les équipes en difficulté +- Valider les choix méthodologiques +- Suggérer des améliorations +- Vérifier la compatibilité inter-équipes + +::: {.fragment} +::: {.callout-tip} +## N'attendez pas ! +Appelez l'enseignant dès qu'un problème bloque toute l'équipe. +::: +::: + +# Intégration Collaborative {background-color="#DC143C"} + +## Le défi de l'intégration + +**Maintenant que chaque équipe a son analyse, il faut tout combiner !** + +::: {.fragment} +**Objectif :** + +Créer un script `analyse_integree.R` qui : + +1. Charge toutes les fonctions des 4 équipes +2. Exécute les 4 analyses +3. Combine les résultats +4. Produit une synthèse globale +::: + +## Exercice 5 : Script d'intégration {.smaller} + +**Les coordinateurs créent ensemble :** + +```{r} +#| eval: false +# === ANALYSE INTÉGRÉE - 4 ÉQUIPES === + +# Charger toutes les fonctions +source("equipe1/fonctions_equipe1.R") +source("equipe2/fonctions_equipe2.R") +source("equipe3/fonctions_equipe3.R") +source("equipe4/fonctions_equipe4.R") + +# Importer et nettoyer les données (commun) +donnees_brutes <- read.csv("dataset_commun.csv") +donnees_propres <- nettoyer_donnees(donnees_brutes) + +# Exécuter les 4 analyses +resultats_e1 <- e1_analyser_temporel(donnees_propres) +resultats_e2 <- e2_analyser_geographique(donnees_propres) +resultats_e3 <- e3_analyser_facteurs(donnees_propres) +resultats_e4 <- e4_analyser_patterns(donnees_propres) + +# Combiner les résultats +synthese <- combiner_resultats( + temporel = resultats_e1, + geo = resultats_e2, + facteurs = resultats_e3, + patterns = resultats_e4 +) + +# Sauvegarder +saveRDS(synthese, "synthese_complete.rds") +write.csv(synthese, "synthese_complete.csv") +``` + +::: {.notes} +20 minutes. Travail collectif d'intégration. +::: + +## Gestion des conflits + +**Problèmes courants :** + +::: {.incremental} +**Fonctions avec le même nom :** + +```{r} +#| eval: false +# Solution : préfixer ou spécifier le package/source +equipe1::analyser() +equipe2::analyser() +``` + +**Structures de données incompatibles :** + +```{r} +#| eval: false +# Solution : créer des fonctions de conversion +convertir_format_equipe1_vers_equipe2 <- function(data) { + # Transformation ici +} +``` + +**Dépendances manquantes :** + +```{r} +#| eval: false +# Solution : documenter toutes les dépendances +# Créer un script setup.R +packages <- c("dplyr", "ggplot2", "lubridate") +install.packages(packages) +``` +::: + +## Test de l'intégration + +**Vérifications essentielles :** + +```{r} +#| eval: false +# Le script complet s'exécute sans erreur ? +source("analyse_integree.R") + +# Les résultats sont cohérents ? +str(synthese) +summary(synthese) + +# Les graphiques s'affichent ? +# Les fichiers de sortie sont créés ? +``` + +::: {.fragment} +**Si ça casse, débuggez ensemble !** +::: + +# Présentations Finales {background-color="#2E8B57"} + +## Format de présentation + +**Présentations par équipe (5 min chacune) :** + +::: {.incremental} +1. **Angle d'analyse** (30 sec) : Quelle perspective ? +2. **Méthodologie** (1 min) : Comment avez-vous procédé ? +3. **Résultats clés** (2 min) : 2-3 insights majeurs avec graphiques +4. **Contribution à la synthèse** (1 min) : Qu'apportez-vous au tout ? +5. **Défis et apprentissages** (30 sec) : Qu'avez-vous appris ? +::: + +## Présentation de la synthèse intégrée + +**Présentation collective (10 min) :** + +- **Vision d'ensemble** : Comment les 4 analyses se complètent ? +- **Insights croisés** : Ce qu'on voit en combinant tout +- **Recommandations** : Conclusions basées sur l'analyse complète +- **Démo du code intégré** : Montrer que tout fonctionne ensemble + +::: {.fragment} +**Tous les coordinateurs présentent ensemble !** +::: + +## Exercice 6 : Préparer la présentation {.smaller} + +**Chaque équipe prépare (10 min) :** + +1. **Sélectionner** les 2-3 graphiques les plus importants +2. **Rédiger** les messages clés (3 bullets maximum) +3. **Préparer** une démo live de votre code +4. **Répéter** le timing (max 5 min !) + +**Pour la synthèse collective :** + +- Les coordinateurs se réunissent +- Créent une présentation intégrée +- Se répartissent la parole + +::: {.notes} +10 minutes de préparation avant les présentations. +::: + +## Feedback et questions + +**Après chaque présentation :** + +- 2 minutes de questions/commentaires +- Feedback constructif des autres équipes +- Points d'amélioration suggérés + +::: {.fragment} +::: {.callout-tip} +## Célébrons les réussites ! +Identifiez ce qui a été particulièrement bien fait dans chaque équipe. +::: +::: + +# Célébration et Bilan {background-color="#4169E1"} + +## Vous avez réussi ! 🎉 + +**Félicitations, vous avez :** + +::: {.incremental} +✅ Collaboré en équipe sur un projet complexe +✅ Intégré différentes analyses en un tout cohérent +✅ Pratiqué le code review professionnel +✅ Géré les conflits et incompatibilités +✅ Communiqué efficacement sur du code +✅ Produit une analyse complète et documentée +✅ Présenté des résultats de manière professionnelle +::: + +## Exercice final : Rétrospective {.smaller} + +**Individuellement, réfléchissez (5 min) :** + +::: {.nonincremental} +**Ce qui a bien fonctionné :** + +- Dans votre équipe ? +- Dans la collaboration inter-équipes ? +- Dans votre propre contribution ? + +**Ce qui a été difficile :** + +- Quels obstacles avez-vous rencontrés ? +- Comment les avez-vous surmontés ? + +**Ce que vous avez appris :** + +- Sur R et la programmation ? +- Sur le travail en équipe ? +- Sur vous-même ? + +**Ce que vous allez réutiliser :** + +- Quelles compétences acquises ? +- Quelles méthodes de travail ? +::: + +## Partage collectif {.smaller} + +**Tour de table (1 min/personne) :** + +Partagez **UNE** chose que vous retenez de ce cours : + +- Une compétence technique +- Une méthode de travail +- Un moment marquant +- Une prise de conscience + +::: {.fragment} +::: {.callout-note} +## Votre parcours +De la séance 1 (découverte de R) à aujourd'hui (projet collaboratif complexe) : vous avez parcouru un chemin immense ! 🚀 +::: +::: + +# Bilan du cours complet {background-color="#8B008B"} + +## Compétences acquises en 8 séances + +**Techniques :** + +::: {.incremental} +- ✅ Programmation R : variables, fonctions, conditions, boucles +- ✅ Manipulation de données : import, nettoyage, transformation (dplyr) +- ✅ Visualisation : ggplot2, graphiques professionnels +- ✅ Organisation : code modulaire, packages, fonctions réutilisables +- ✅ Automatisation : traitement par lots, rapports paramétrés +- ✅ Documentation : R Markdown, commentaires, documentation +::: + +## Compétences transversales + +**Méthodologiques :** + +::: {.incremental} +- ✅ Résolution de problèmes par décomposition +- ✅ Debugging systématique +- ✅ Tests et validation du code +- ✅ Gestion d'erreurs et cas particuliers +::: + +**Collaboration :** + +::: {.incremental} +- ✅ Travail en équipe sur du code +- ✅ Code review constructif +- ✅ Communication technique +- ✅ Intégration de travaux multiples +::: + +## Utilisation des LLMs + +**Vous savez maintenant :** + +::: {.incremental} +- ✅ Formuler des prompts **précis** et **contextualisés** +- ✅ **Valider** critiquement les réponses +- ✅ **Itérer** pour améliorer les résultats +- ✅ **Identifier** les erreurs et limites des LLMs +- ✅ Utiliser les LLMs comme **partenaires**, pas comme **oracle** +::: + +::: {.fragment} +::: {.callout-tip} +## L'esprit critique +La compétence la plus importante que vous avez développée ! +::: +::: + +## Votre progression + +::: {.nonincremental} +**Séance 1 :** +"Qu'est-ce que R ?" + +**Séance 2 :** +"Comment importer des données ?" + +**Séance 3 :** +"Comment créer une fonction ?" + +**Séance 4 :** +"Comment faire de beaux graphiques ?" + +**Séance 5 :** +"Analyse complète en autonomie !" + +**Séance 6 :** +"Organisation professionnelle du code" + +**Séance 7 :** +"Automatisation et rapports" + +**Séance 8 :** +"Projet collaboratif complexe !" ✨ +::: + +## Et maintenant ? + +**Vous êtes capables de :** + +::: {.incremental} +- Analyser des données **en autonomie** +- Créer des **outils réutilisables** +- **Automatiser** des tâches répétitives +- **Collaborer** sur des projets data +- **Continuer à apprendre** par vous-même avec les LLMs +::: + +::: {.fragment} +::: {.callout-note} +## Le plus important +Vous n'avez plus peur du code ! 🎓 +::: +::: + +# Ressources pour continuer {background-color="#2E8B57"} + +## Poursuivre votre apprentissage + +**Ressources en ligne :** + +- [R for Data Science](https://r4ds.hadley.nz/) - livre gratuit +- [RStudio Cheatsheets](https://posit.co/resources/cheatsheets/) +- [Stack Overflow](https://stackoverflow.com/questions/tagged/r) - communauté +- Votre journal de bord - vos propres notes ! + +**Pratiquer :** + +- Kaggle - datasets et compétitions +- TidyTuesday - défis hebdomadaires +- Vos propres projets - le meilleur apprentissage ! + +## Rester en contact + +**Communauté :** + +- Continuez à échanger avec vos camarades +- Partagez vos projets +- Aidez les nouveaux arrivants +- Contribuez à des projets open source + +**Avec les LLMs :** + +- Continuez à les utiliser **critiquement** +- Documentez vos meilleures pratiques +- Partagez vos découvertes + +## Merci ! 🙏 + +**Merci pour :** + +- Votre **engagement** tout au long du cours +- Votre **curiosité** et vos questions +- Votre **collaboration** avec vos pairs +- Votre **persévérance** face aux difficultés + +::: {.fragment} +**Vous êtes maintenant des programmeurs R capables ! 🚀** +::: + +::: {.fragment} +**Continuez à coder, continuez à apprendre, continuez à créer !** +::: + +## Questions finales ? + +::: {.callout-tip} +## N'oubliez jamais + +- Le **code** est un outil, pas une fin en soi +- Les **erreurs** sont des opportunités d'apprentissage +- La **collaboration** enrichit vos compétences +- L'**apprentissage** ne s'arrête jamais +- Les **LLMs** sont des assistants, vous êtes le cerveau ! +::: + +::: {.fragment} +**Bon courage pour vos futurs projets ! 🎉** +::: \ No newline at end of file diff --git a/ECLibre/script_automatisation.R b/ECLibre/script_automatisation.R new file mode 100644 index 0000000..ab9fd3e --- /dev/null +++ b/ECLibre/script_automatisation.R @@ -0,0 +1,77 @@ +# Script d'automatisation pour générer des rapports +# Ce script montre comment générer automatiquement plusieurs rapports + +library(rmarkdown) + +# Fonction pour générer un rapport +generer_rapport <- function(fichier_donnees, output_dir = "rapports/") { + # Extraire le nom du fichier sans extension + nom_base <- tools::file_path_sans_ext(basename(fichier_donnees)) + + # Créer le dossier de sortie si nécessaire + if (!dir.exists(output_dir)) { + dir.create(output_dir, recursive = TRUE) + } + + # Générer le rapport + output_file <- file.path(output_dir, paste0("rapport_", nom_base, ".html")) + + rmarkdown::render( + "template_analyse.Rmd", + params = list( + dataset = fichier_donnees, + titre = paste("Analyse de", nom_base) + ), + output_file = output_file + ) + + message("Rapport généré : ", output_file) + return(output_file) +} + +# Fonction pour analyser un dossier +analyser_dossier <- function(chemin, pattern = "\\.csv$") { + # Lister les fichiers + fichiers <- list.files(path = chemin, pattern = pattern, + full.names = TRUE) + + if (length(fichiers) == 0) { + stop("Aucun fichier trouvé !") + } + + # Analyser chaque fichier + resultats <- lapply(fichiers, function(f) { + tryCatch({ + donnees <- read.csv(f) + data.frame( + fichier = basename(f), + n_lignes = nrow(donnees), + n_colonnes = ncol(donnees), + colonnes = paste(names(donnees), collapse = ", ") + ) + }, error = function(e) { + message("Erreur avec ", f, ": ", e$message) + data.frame( + fichier = basename(f), + n_lignes = NA, + n_colonnes = NA, + colonnes = "ERREUR" + ) + }) + }) + + # Combiner et retourner + do.call(rbind, resultats) +} + +# Exemple d'utilisation : générer des rapports pour tous les fichiers de ventes +if (interactive()) { + # Lister les fichiers de ventes + fichiers <- list.files("donnees/", pattern = "ventes_.*\\.csv$", full.names = TRUE) + + # Générer un rapport pour chaque fichier + rapports <- lapply(fichiers, generer_rapport) + + cat("\n✓ Tous les rapports ont été générés avec succès !\n") + cat("Nombre de rapports:", length(rapports), "\n") +} diff --git a/ECLibre/template_analyse.Rmd b/ECLibre/template_analyse.Rmd new file mode 100644 index 0000000..171db53 --- /dev/null +++ b/ECLibre/template_analyse.Rmd @@ -0,0 +1,147 @@ +--- +title: "`r params$titre`" +author: "Rapport automatisé" +date: "`r format(Sys.Date(), '%d %B %Y')`" +params: + dataset: "donnees/ventes_janvier.csv" + titre: "Analyse de ventes" +output: + html_document: + toc: true + toc_float: true + theme: flatly + highlight: tango +--- + +```{r setup, include=FALSE} +knitr::opts_chunk$set(echo = TRUE, warning = FALSE, message = FALSE) +library(ggplot2) +``` + +# Introduction + +Ce rapport présente une analyse automatisée des données contenues dans le fichier : **`r basename(params$dataset)`** + +# Importation des données + +```{r} +# Importer les données +donnees <- read.csv(params$dataset) + +# Aperçu des données +head(donnees) +``` + +# Statistiques descriptives + +```{r} +# Structure des données +str(donnees) + +# Résumé statistique +summary(donnees) +``` + +## Statistiques par région + +```{r} +# Nombre de transactions par région +table(donnees$region) + +# Montant total par région +aggregate(montant ~ region, data = donnees, FUN = sum) + +# Montant moyen par région +aggregate(montant ~ region, data = donnees, FUN = mean) +``` + +# Visualisations + +## Distribution des montants + +```{r, fig.width=8, fig.height=5} +ggplot(donnees, aes(x = montant)) + + geom_histogram(binwidth = 500, fill = "steelblue", color = "white") + + labs(title = "Distribution des montants de vente", + x = "Montant (€)", + y = "Fréquence") + + theme_minimal() +``` + +## Ventes par produit + +```{r, fig.width=8, fig.height=5} +# Calculer le total par produit +ventes_produit <- aggregate(montant ~ produit, data = donnees, FUN = sum) + +ggplot(ventes_produit, aes(x = reorder(produit, montant), y = montant)) + + geom_bar(stat = "identity", fill = "coral") + + coord_flip() + + labs(title = "Montant total des ventes par produit", + x = "Produit", + y = "Montant total (€)") + + theme_minimal() +``` + +## Ventes par région + +```{r, fig.width=8, fig.height=5} +# Calculer le total par région +ventes_region <- aggregate(montant ~ region, data = donnees, FUN = sum) + +ggplot(ventes_region, aes(x = region, y = montant, fill = region)) + + geom_bar(stat = "identity") + + scale_fill_brewer(palette = "Set2") + + labs(title = "Montant total des ventes par région", + x = "Région", + y = "Montant total (€)") + + theme_minimal() + + theme(legend.position = "none") +``` + +# Analyse détaillée + +## Performance globale + +```{r} +# Métriques clés +montant_total <- sum(donnees$montant) +montant_moyen <- mean(donnees$montant) +quantite_totale <- sum(donnees$quantite) +nb_transactions <- nrow(donnees) + +cat("Montant total des ventes:", format(montant_total, big.mark = " "), "€\n") +cat("Montant moyen par transaction:", round(montant_moyen, 2), "€\n") +cat("Quantité totale vendue:", quantite_totale, "unités\n") +cat("Nombre de transactions:", nb_transactions, "\n") +``` + +## Produit le plus vendu + +```{r} +# Produit avec le plus haut montant de ventes +produit_top <- ventes_produit[which.max(ventes_produit$montant), ] +cat("Le produit le plus vendu est:", produit_top$produit, + "avec un montant total de", format(produit_top$montant, big.mark = " "), "€\n") +``` + +## Région la plus performante + +```{r} +# Région avec le plus haut montant de ventes +region_top <- ventes_region[which.max(ventes_region$montant), ] +cat("La région la plus performante est:", region_top$region, + "avec un montant total de", format(region_top$montant, big.mark = " "), "€\n") +``` + +# Conclusion + +Ce rapport a analysé **`r nb_transactions` transactions** représentant un montant total de **`r format(montant_total, big.mark = " ")` €**. + +- Le produit le plus vendu est : **`r produit_top$produit`** +- La région la plus performante est : **`r region_top$region`** +- Le montant moyen par transaction est de : **`r round(montant_moyen, 2)` €** + +--- + +*Rapport généré automatiquement le `r Sys.time()`* \ No newline at end of file diff --git a/JournalBord.qmd b/JournalBord.qmd new file mode 100644 index 0000000..6bc393f --- /dev/null +++ b/JournalBord.qmd @@ -0,0 +1,84 @@ +--- +title: "Journal de bord cours Initiation à R avec un LLM" +subtitle: "Modèle à reproduire" +author: "Nom Prénom" +date: last-modified +lang: fr +format: html +--- + +```{r} + +``` + +# Instructions d'utilisation + +1. Copiez ce template pour chaque session de travail +2. Remplissez une nouvelle entrée pour chaque interaction avec un LLM +3. Prenez le temps de réfléchir après chaque interaction +4. Revisitez vos anciens logs pour identifier des patterns et progresser + +# Entrée #[Numéro] + +## 📝 Prompt utilisé + +``` {md} +[Copiez ici exactement le prompt que vous avez utilisé avec le LLM] +``` + +## 🤖 Réponse du LLM + +```{md} +[Copiez ici la réponse complète du LLM] +``` + +## 🔄 Prompt amélioré (si besoin) + +```{md} +[Si vous refaisiez ce prompt, comment l'écririez-vous? Pourquoi?] +``` + +## 🤖 Réponse au prompt amélioré du LLM + +```{md} +[Copiez ici la réponse complète du LLM] +``` + +## 💭 Vos réflexions sur le prompt + +- **Clarté du prompt :** _[Le prompt était-il clair et précis?]_ +- **Résultat attendu vs obtenu :** _[La réponse correspondait-elle à vos attentes?]_ +- **Points positifs :** _[Qu'est-ce qui a bien fonctionné?]_ +- **Points à améliorer :** _[Comment pourriez-vous améliorer ce prompt?]_ +- **Apprentissages :** _[Qu'avez-vous appris de cette interaction?]_ + + + + +# 📊 Bilan de session + +### Résumé des interactions + +_[Nombre total d'interactions, thèmes abordés]_ + +### Évolution des compétences de prompting + +_[Comment vos prompts ont-ils évolué au cours de cette session?]_ + + + +### Stratégies efficaces identifiées + +_[Quelles approches de prompting ont le mieux fonctionné?]_ + +### Objectifs pour la prochaine session + +_[Quels aspects du prompting voulez-vous améliorer?]_ + + +### Évolution des compétences de R + +_[Comment votre compréhension de R a progressé ?]_ + +--- + diff --git a/LICENSE b/LICENSE index 0e259d4..ca9dc60 100644 --- a/LICENSE +++ b/LICENSE @@ -1,121 +1,4 @@ -Creative Commons Legal Code +Unless noted otherwise, the entirety of this repository is licence under the CC BY-SA 4.0. -CC0 1.0 Universal - - CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE - LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN - ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS - INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES - REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS - PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM - THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED - HEREUNDER. - -Statement of Purpose - -The laws of most jurisdictions throughout the world automatically confer -exclusive Copyright and Related Rights (defined below) upon the creator -and subsequent owner(s) (each and all, an "owner") of an original work of -authorship and/or a database (each, a "Work"). - -Certain owners wish to permanently relinquish those rights to a Work for -the purpose of contributing to a commons of creative, cultural and -scientific works ("Commons") that the public can reliably and without fear -of later claims of infringement build upon, modify, incorporate in other -works, reuse and redistribute as freely as possible in any form whatsoever -and for any purposes, including without limitation commercial purposes. -These owners may contribute to the Commons to promote the ideal of a free -culture and the further production of creative, cultural and scientific -works, or to gain reputation or greater distribution for their Work in -part through the use and efforts of others. - -For these and/or other purposes and motivations, and without any -expectation of additional consideration or compensation, the person -associating CC0 with a Work (the "Affirmer"), to the extent that he or she -is an owner of Copyright and Related Rights in the Work, voluntarily -elects to apply CC0 to the Work and publicly distribute the Work under its -terms, with knowledge of his or her Copyright and Related Rights in the -Work and the meaning and intended legal effect of CC0 on those rights. - -1. Copyright and Related Rights. A Work made available under CC0 may be -protected by copyright and related or neighboring rights ("Copyright and -Related Rights"). Copyright and Related Rights include, but are not -limited to, the following: - - i. the right to reproduce, adapt, distribute, perform, display, - communicate, and translate a Work; - ii. moral rights retained by the original author(s) and/or performer(s); -iii. publicity and privacy rights pertaining to a person's image or - likeness depicted in a Work; - iv. rights protecting against unfair competition in regards to a Work, - subject to the limitations in paragraph 4(a), below; - v. rights protecting the extraction, dissemination, use and reuse of data - in a Work; - vi. database rights (such as those arising under Directive 96/9/EC of the - European Parliament and of the Council of 11 March 1996 on the legal - protection of databases, and under any national implementation - thereof, including any amended or successor version of such - directive); and -vii. other similar, equivalent or corresponding rights throughout the - world based on applicable law or treaty, and any national - implementations thereof. - -2. Waiver. To the greatest extent permitted by, but not in contravention -of, applicable law, Affirmer hereby overtly, fully, permanently, -irrevocably and unconditionally waives, abandons, and surrenders all of -Affirmer's Copyright and Related Rights and associated claims and causes -of action, whether now known or unknown (including existing as well as -future claims and causes of action), in the Work (i) in all territories -worldwide, (ii) for the maximum duration provided by applicable law or -treaty (including future time extensions), (iii) in any current or future -medium and for any number of copies, and (iv) for any purpose whatsoever, -including without limitation commercial, advertising or promotional -purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each -member of the public at large and to the detriment of Affirmer's heirs and -successors, fully intending that such Waiver shall not be subject to -revocation, rescission, cancellation, termination, or any other legal or -equitable action to disrupt the quiet enjoyment of the Work by the public -as contemplated by Affirmer's express Statement of Purpose. - -3. Public License Fallback. Should any part of the Waiver for any reason -be judged legally invalid or ineffective under applicable law, then the -Waiver shall be preserved to the maximum extent permitted taking into -account Affirmer's express Statement of Purpose. In addition, to the -extent the Waiver is so judged Affirmer hereby grants to each affected -person a royalty-free, non transferable, non sublicensable, non exclusive, -irrevocable and unconditional license to exercise Affirmer's Copyright and -Related Rights in the Work (i) in all territories worldwide, (ii) for the -maximum duration provided by applicable law or treaty (including future -time extensions), (iii) in any current or future medium and for any number -of copies, and (iv) for any purpose whatsoever, including without -limitation commercial, advertising or promotional purposes (the -"License"). The License shall be deemed effective as of the date CC0 was -applied by Affirmer to the Work. Should any part of the License for any -reason be judged legally invalid or ineffective under applicable law, such -partial invalidity or ineffectiveness shall not invalidate the remainder -of the License, and in such case Affirmer hereby affirms that he or she -will not (i) exercise any of his or her remaining Copyright and Related -Rights in the Work or (ii) assert any associated claims and causes of -action with respect to the Work, in either case contrary to Affirmer's -express Statement of Purpose. - -4. Limitations and Disclaimers. - - a. No trademark or patent rights held by Affirmer are waived, abandoned, - surrendered, licensed or otherwise affected by this document. - b. Affirmer offers the Work as-is and makes no representations or - warranties of any kind concerning the Work, express, implied, - statutory or otherwise, including without limitation warranties of - title, merchantability, fitness for a particular purpose, non - infringement, or the absence of latent or other defects, accuracy, or - the present or absence of errors, whether or not discoverable, all to - the greatest extent permissible under applicable law. - c. Affirmer disclaims responsibility for clearing rights of other persons - that may apply to the Work or any use thereof, including without - limitation any person's Copyright and Related Rights in the Work. - Further, Affirmer disclaims responsibility for obtaining any necessary - consents, permissions or other rights required for any use of the - Work. - d. Affirmer understands and acknowledges that Creative Commons is not a - party to this document and has no duty or obligation with respect to - this CC0 or use of the Work. +Introduction to R © 2024 by Elias Bouacida is licensed under CC BY-SA 4.0. +To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/4.0/ \ No newline at end of file diff --git a/M3P/01Introduction.qmd b/M3P/01Introduction.qmd new file mode 100644 index 0000000..ce1f1a3 --- /dev/null +++ b/M3P/01Introduction.qmd @@ -0,0 +1,550 @@ +--- +title: "Apprendre la Programmation (en R) avec les LLMs" +subtitle: "" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + slide-number: true + incremental: true + smaller: false + scrollable: true + link-external-newwindow: true + output-file: slide-introduction.html + embed-resources: true +format-links: [revealjs] +lang: fr +--- + +# Introduction + +## Bienvenue ! 🚀 + +**Apprendre la Programmation (en R) avec les LLMs** + + +:::: {.columns} +::: {.column width="33%"} +**🤖 LLM = Votre Assistant** + +LLM : Large Language Model, aussi connu sous le nom d'IA générative + +Ex : ChatGPT, Claude, Mistral, etc. +::: + +::: {.column width="33%"} +**📊 R = Langage Statistique** + +Pour analyser, visualiser, calculer +::: + +::: {.column width="33%"} +**🎯 Objectif = Collaboration** + +Programmer AVEC l'IA générative intelligemment +::: +:::: + +## Sondage 📊 + +**Levez la main si vous avez déjà (Pas de jugement ! 😊)...** + +- Utilisé un LLM (ChatGPT, Claude, etc) ? 🙋‍♀️ +- Demandé leur aide pour un devoir ? 📝 +- Copié-collé une de leur réponse sans la comprendre ? 😅 +- Fait confiance aveuglément à un LLM ? 🤖 +- Payé pour un LLM ? +- Programmé dans n'importe quel langage de programmation ? 💻 + + +# Pourquoi ce cours ? 🎯 + +## Que va-t-on apprendre ? + + + +### Comment utilisez-vous des LLMs ? + + + +::: {.fragment} + +### L'approche ici + +- Poser les BONNES questions +- Vérifier et corriger les erreurs +- Comprendre les réponses +- Utiliser le LLM comme partenaire + +::: + +::: {.fragment} +**Objectif :** Autonomie et esprit critique + +::: + +::: { .notes } +Ici, demander des exemples de ce qu'ils font +::: + +## Démonstration : Prompt + +:::: {.columns} +::: {.column width="50%" .fragment} +### Prompt 1 (Essayez !) + +``` +"Fais-moi des statistiques sur mes données" +``` + +- Problème : Trop vague ! +- Quelles données ? +- Quelles statistiques ? +- Quel format de sortie ? +::: + +::: {.column width="49%" .fragment} +### Prompt 2 + +``` +"J'ai 10 notes d'étudiants : +12, 15, 18, 14, 16, 13, 17, 11, 19, 15. +Calcule la moyenne, médiane et l'écart-type +en R avec des commentaires explicatifs." +``` + +**Résultat :** Code précis et commenté ! +::: +:::: + +::: {.notes} +Proposer aux étudiants de le faire eux-même. +Commencez par le prompt 1, puis les amener au prompt 2 en formalisant un peu le problème. +::: + + +## Objectif du cours + +- Apprendre à utiliser R et Rstudio +- Apprendre à utiliser les principales librairies (aussi appelées paquets) de R pour l'analyse de données et les statistiques (le tidyverse) +- Vous apprendre à utiliser des LLMs pour faire cela + + + +# R et Rstudio ? 📊 + +## R et RStudio : Vos nouveaux outils + +:::: {.columns} + +::: {.column width="50%" .fragment } + +### R = Le Moteur 🚗 + +- Langage de programmation +- Spécialisé en analyse de données +- Dérive d'un langage antérieur appelé S +- Est un [logiciel libre](https://fr.wikipedia.org/wiki/Logiciel_libre) + +::: + +::: {.column width="50%" .fragment } + +### RStudio = L'Interface 🖥️ + +- Environnement convivial +- Facilite l'écriture de code R +- Intègre tout en un endroit +- Comme Word pour l'écriture + +::: + +:::: + +## Exemples concrets d'usage 🌟 + +- 📈 **Analyser un sondage** : "Quel pourcentage préfère le chocolat ?" +- 📊 **Créer des graphiques** : Histogrammes, courbes, diagrammes +- 🧮 **Calculs statistiques** : Moyennes, corrélations, tests +- 🏃 **Données géographiques** : Cartes +- 📋 **Nettoyer des données** : Corriger, organiser, structurer +- 🎯 **Prédictions simples** : "Quelle sera la prochaine tendance ?" + +## Premier aperçu du code R + +```{r moyenne} +#| echo: true +#| eval: true + +# Créer une liste de notes +notes <- c(15, 12, 18, 14, 16, 13, 17) +# Calculer la moyenne +moyenne <- mean(notes) +# Afficher le résultat +print(paste("La moyenne est :", moyenne)) +``` + +**C'est tout ! Pas si compliqué, non ?** 😊 + +# Comment ça marche avec un LLM ? 🤝 + +## Le processus en 4 étapes + +1. 🎯 Formuler une question précise + - Au lieu de "fais-moi des calculs" + - Dire "calcule la moyenne de ces 5 notes : 12, 15, 18, 14, 16" + +2. 🤖 Recevoir et comprendre la réponse + - Le LLM vous donne du code + des explications (si vous lui demandez) + +3. 🧪 Tester et vérifier + - Exécuter le code, voir si ça marche, comprendre pourquoi + +4. ✨ Améliorer si nécessaire + - Corriger les erreurs, adapter à vos besoins + +## Exemple + +Votre demande (à votre LLM préféré) +``` +"J'ai des données de vente par mois : +Janvier : 1500€, Février : 2000€, Mars : 1800€ +Crée un graphique en barres avec R" +``` + +Essayez ! + +## Exemple (réponse possible) + + +```{r vente-code} +#| eval: false +#| echo: true + +# Données de vente +mois <- c("Janvier", "Février", "Mars") +ventes <- c(1500, 2000, 1800) + +# Créer le graphique +barplot(ventes, names.arg = mois, + main = "Ventes par mois", + ylab = "Montant (€)") +``` + +## Le résultat + +```{r vente-graph} +#| echo: true +#| eval: true +#| fig-width: 8 +#| fig-height: 4 + +# Testons le code ! +mois <- c("Janvier", "Février", "Mars") +ventes <- c(1500, 2000, 1800) + +barplot(ventes, names.arg = mois, + main = "Ventes par mois", + ylab = "Montant (€)", + col = "steelblue") +``` + +# Les Erreurs : Vos Amies ! 🐛 + +## Pourquoi on fera des erreurs + +**Principe pédagogique :** Les erreurs sont des occasions d'apprentissage, pas des échecs ! + +- 🎯 **Développer votre esprit critique** +- 🔍 **Apprendre à déboguer** +- 🤖 **Comprendre les limites des LLM** +- 💪 **Gagner en autonomie** +- 🧠 **Mémoriser par l'expérience** + + + +# Organisation du Cours + +## 8 Séances de 3 heures 📅 + +Le cours est structuré en 3 phases progressives sur 8 séances de 3h. + +### Phase 1 : Fondations 🌱 (Séances 1-3) + +**Objectif :** Maîtriser le dialogue avec un LLM et les concepts R de base + +#### Séance 1 : Premiers pas avec R + +::: {.nonincremental} +- Découvrir RStudio et son interface +- Comprendre les concepts de base : objets, types, vecteurs +- Utiliser des fonctions intégrées +- Créer son premier script +- Commencer son journal de bord +::: + +#### Séance 2 : Données et visualisations + +::: {.nonincremental} +- Importer des données réelles (fichiers CSV) +- Explorer des dataframes +- Calculer des statistiques descriptives +- Créer des visualisations simples +- Apprendre à déboguer efficacement +::: + +#### Séance 3 : Automatisation et fonctions + +::: {.nonincremental} +- Utiliser des conditions (`if/else`) +- Créer des boucles (`for`, `while`) +- Écrire vos propres fonctions +- Combiner tous les concepts appris +::: + +### Phase 2 : Application 🚀 (Séances 4-5) + +**Objectif :** Analyser de vraies données en autonomie + +#### Séance 4 : Données tabulaires et graphiques avancés + +::: {.nonincremental} +- Maîtriser les dataframes complexes +- Nettoyage de données (casse, formats, incohérences) +- Visualisations avec ggplot2 +- Créer des fonctions de visualisation réutilisables +::: + +#### Séance 5 : Projet personnel intégré + +::: {.nonincremental} +- Choix et cadrage d'un projet personnel +- Analyse complète de A à Z en autonomie +- Présentation des résultats aux pairs +::: + +### Phase 3 : Expertise ⭐ (Séances 6-8) + +**Objectif :** Devenir autonome et collaborer efficacement + +#### Séance 6 : Organisation et modularité + +::: {.nonincremental} +- Structurer son code en modules +- Découvrir l'écosystème des packages (`dplyr`, `lubridate`) +- Organiser ses fonctions en scripts thématiques +::: + +#### Séance 7 : Automatisation et rapports + +::: {.nonincremental} +- Automatiser des analyses répétitives +- Traiter plusieurs fichiers à la fois +- Créer des rapports reproductibles avec markdown +::: + +#### Séance 8 : Projet collaboratif final + +::: {.nonincremental} +- Travailler en équipe sur un grand dataset +- Code review croisé entre équipes +- Intégrer les bonnes pratiques de développement +- Présentation finale +::: + +## Progression pédagogique + +::: {.incremental} +- **Séances 1-3** → Bases : concepts fondamentaux et autonomie technique +- **Séances 4-5** → Application : projets personnels et analyses complètes +- **Séances 6-8** → Expertise : organisation, automatisation et collaboration +::: + +::: {.fragment} +**À la fin du cours, vous serez capable de :** analyser des données en autonomie, créer vos propres outils, automatiser vos analyses, collaborer sur du code, et utiliser les LLMs comme de véritables partenaires de travail. +::: + +## Structure d'une séance type + +:::: {.columns} +::: {.column width="33%"} +### 🎭 Présentation +**30-60 min** + +- Concepts du jour +- Démonstrations en direct +- Exemples concrets +::: + +::: {.column width="33%"} +### 💻 Pratique +**90-120 min** + +- Exercices sur machine +- Aide individuelle +- Déboguing collectif +::: + +::: {.column width="33%"} +### 🤝 Partage +**30 min** + +- Retours d'expérience +- Solutions créatives +::: +:::: + +# Évaluation 📊 + +## Une évaluation bienveillante + +**Cours noté** : L'objectif est d'évaluer votre progression, pas de vous piéger ! + +### Composition de la note + +Votre note finale est répartie en 3 composantes : + +```{r notes} +#| echo: false +#| eval: true +#| fig-width: 8 +#| fig-height: 5 +#| fig-align: "center" + +# Création d'un graphique des évaluations +library(ggplot2) +evaluations <- data.frame( + Type = c("Journal de bord", "Mini-projets", "Participation"), + Poids = c(40, 40, 20), + Description = c("Apprentissage", "Rendus", "En classe") +) + +ggplot(evaluations, aes(x = reorder(Type, -Poids), y = Poids, fill = Type)) + + geom_bar(stat = "identity") + + geom_text(aes(label = paste(Poids, "%")), vjust = -0.5, size = 6) + + labs(y = "Pourcentage de la note", x = "") + + theme_minimal() + + theme(legend.position = "none", + text = element_text(size = 14), + axis.text.x = element_text(size = 12)) +``` + +## 📓 Journal de bord (40%) {.smaller} + +Document votre apprentissage tout au long du semestre. + +**Pour chaque séance, notez :** + +::: {.nonincremental} +- Les **prompts** utilisés avec les LLMs (copier-coller exact) +- Les **réponses** obtenues (copier-coller, pas de captures d'écran) +- Votre **compréhension** avec vos propres mots +- Les **difficultés** et erreurs rencontrées +- Les **solutions** trouvées +- Le **code** produit et commenté +::: + +::: {.fragment} +::: {.callout-tip} +## Soyez honnête ! +Documentez vos échecs comme vos réussites. C'est votre progression qui compte. +::: +::: + +## 🎯 Mini-projets (40%) {.smaller} + +Rendus de fin de séance à soumettre sur Moodle. + +::: {.nonincremental} +- **Séance 1** : Script commenté avec analyse de données simple +- **Séance 2** : Analyse de données INSEE avec visualisations +- **Séance 3** : Fonctions personnalisées pour analyse de températures +::: + +::: {.fragment} +**Critères :** Code fonctionnel, commenté, résout le problème posé +::: + +## 👥 Participation (20%) {.smaller} + +Votre engagement pendant les séances. + +::: {.incremental} +- **Présence active** : Vous travaillez sur les exercices +- **Entraide** : Vous aidez vos camarades ou demandez de l'aide +- **Déboguing collectif** : Vous partagez vos solutions +- **Questions** : Vous posez des questions pertinentes +::: + +::: {.fragment} +::: {.callout-note} +## Pas de stress ! +La participation, ce n'est pas parler beaucoup, c'est être engagé dans votre apprentissage. +::: +::: + + +# Questions & Discussion 💬 + +## Vos interrogations + +**Quelles sont vos questions ?** 🤔 + +- 🤖 Sur l'utilisation des LLM ? +- 📊 Sur le langage R ? +- 📅 Sur l'organisation du cours ? +- 📝 Sur l'évaluation ? + +**Pas de question bête !** Nous sommes tous là pour apprendre ensemble 😊 + +# Prochaines Étapes 🎯 + +## Maintenant + +1. 📥 **Installer R et RStudio** (tutoriel fourni, si sur votre machine, démarrez Rstudio sinon) +2. 🔐 **Créer un compte LLM** (facultatif) +4. 🧪 **Essayer un premier prompt** simple + +## Merci ! + +*N'oubliez pas : l'erreur est votre amie !* 😊 + +:::: {.columns} +::: {.column width="33%"} +**📚 Apprenez** +::: + +::: {.column width="33%"} +**🔍 Explorez** +::: + +::: {.column width="33%"} +**🎉 Réussissez** +::: +:::: + +## Ressources disponibles + +### 🔗 Liens utiles + +::: {.nonincremental} + +- Installation R/RStudio : +- Utilisation de R/Rstudio en ligne : (Utilisez votre compte étudiant Paris 8 pour vous connecter) +- Guide des prompts efficaces : + + +::: + +## Contact et ressources + +::: {.nonincremental} +- 📧 **Email :** [elias.bouacida@univ-paris8.fr](mailto:elias.bouacida@univ-paris8.fr) +- 🌐 **Espace de cours :** [Moodle](https://moodle.univ-paris8.fr/course/view.php?id=18115) +- 🌐 **Cours :** [Cours](https://eliasbcd.github.io/rl3/) +- Bureau : Bâtiment D, Salle D115 +- Permanences : Mardi 14h-16h, Mercredi 14h-16h +::: + diff --git a/M3P/02Lecon1.qmd b/M3P/02Lecon1.qmd new file mode 100644 index 0000000..912823e --- /dev/null +++ b/M3P/02Lecon1.qmd @@ -0,0 +1,581 @@ +--- +title: "Séance 1 : Premiers pas avec R" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon1.html + embed-resources: true + footer: "Séance 1 - Premiers pas avec R" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Présentation** (15min) : Le cours et les outils +- **Découverte de l'interface RStudio** (30min) : Se repérer dans l'environnement +- **Premiers calculs** (30min) : R comme une calculatrice +- **Concepts de base** (60min) : Objets, assignation, types +- **Fonctions intégrées** (45min) : Utiliser des fonctions existantes +- **Premier script** (30min) : Organiser son code +::: + +::: {.fragment} +**Production attendue :** Journal de bord documentant votre découverte de R +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Découvrir R et apprendre avec les LLMs +::: + +::: {.incremental} +- Comprendre ce qu'est R et à quoi il sert +- Se familiariser avec **RStudio** +- Maîtriser les **concepts fondamentaux** : objets, types, fonctions +- Apprendre à **utiliser les LLMs** comme assistants d'apprentissage +- Commencer son **journal de bord** +::: + + + +# Découverte de RStudio {background-color="#4169E1"} + +## Exercice 1 : Explorer l'interface {.smaller} + +Ouvrez RStudio sur votre ordinateur. + + + +::: {.fragment} +**Explorez ensuite :** + +1. La **console** (en bas à gauche généralement) +2. L'**éditeur** de scripts (en haut à gauche) +3. L'**environnement** (en haut à droite) +4. Les **fichiers/graphiques** (en bas à droite) +::: + +::: {.notes} +10 minutes. Laisser les étudiants découvrir l'interface. Circuler pour aider. Vérifier que tout le monde a RStudio installé et fonctionnel. +::: + +## Exercice 2 : La console interactive {.smaller} + +La **console** permet d'exécuter du code R directement. + +**Testez dans la console :** + +```{r} +#| eval: false +2 + 2 +``` + +::: {.fragment} +**Ensuite, essayez :** + +```{r} +#| eval: false +10 - 3 +5 * 4 +20 / 5 +``` +::: + +::: {.fragment} +::: {.callout-tip} +## Astuce +Appuyez sur **Entrée** pour exécuter. R affiche immédiatement le résultat ! +::: +::: + +::: {.notes} +10 minutes. Concept simple, mais fondamental. Insister sur l'aspect interactif. +::: + +# Premiers calculs {background-color="#FF8C00"} + +## R comme calculatrice + +R peut effectuer tous les calculs mathématiques de base. + +::: {.incremental} +- Addition : `+` +- Soustraction : `-` +- Multiplication : `*` +- Division : `/` +- Puissance : `^` +::: + +## Exercice 3 : Calculer une moyenne {.smaller} + +**Situation :** Dans votre classe, les notes sont 12, 15, 13 et 8. + +**Question :** Comment calculer la moyenne avec R ? + +::: {.fragment} +Demandez à votre LLM : + +> "Comment calculer la moyenne de ces notes en R : 12, 15, 13, 8 ?" +::: + +::: {.fragment} +**Testez le code proposé dans la console.** +::: + +::: {.notes} +15 minutes. Premier contact avec c() et mean(). Ne pas tout expliquer maintenant -- laisser les étudiants découvrir avec le LLM. +::: + +## Comprendre le code {.smaller} + +Vous avez probablement obtenu quelque chose comme : + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +mean(notes) +``` + +::: {.fragment} +**Demandez au LLM d'expliquer :** + +1. Que fait `c()` ? +2. Que signifie `<-` ? +3. Que fait `mean()` ? +::: + +::: {.fragment} +::: {.callout-note} +## Vocabulaire à découvrir +- **Vecteur** : `c()` crée une collection de valeurs +- **Assignation** : `<-` stocke une valeur dans un objet +- **Fonction** : `mean()` calcule la moyenne +::: +::: + +# Concepts fondamentaux {background-color="#8B008B"} + +## Les objets en R + +En R, on stocke des valeurs dans des **objets** (aussi appelés **variables**). + +::: {.fragment} +```{r} +#| eval: false +age <- 20 +nom <- "Alice" +est_etudiant <- TRUE +``` +::: + +::: {.fragment} +::: {.callout-tip} +## Analogie +Un objet est comme une boîte avec une étiquette (son nom) qui contient une valeur. +::: +::: + +## Exercice 4 : Créer des objets {.smaller} + +**Créez les objets suivants :** + +```{r} +#| eval: false +votre_prenom <- "..." +votre_age <- ... +annee_naissance <- 2025 - votre_age +``` + +Ensuite, affichez-les en tapant simplement leur nom dans la console. + +::: {.fragment} +**Questions à explorer avec le LLM :** + +1. Peut-on mettre des espaces dans les noms d'objets ? +2. Quelle est la différence entre `<-` et `=` ? +3. Comment supprimer un objet ? +::: + +::: {.notes} +15 minutes. Exercice pratique simple. Les étudiants découvrent les règles de nommage. +::: + +## Les types de données + +R distingue différents **types** de données : + +::: {.incremental} +- **Numérique** : `42`, `3.14` +- **Caractère** (texte) : `"Bonjour"`, `"Paris"` +- **Logique** : `TRUE`, `FALSE` +::: + +::: {.fragment} +**Pour vérifier le type :** + +```{r} +#| eval: false +age <- 20 +class(age) +``` +::: + +## Exercice 5 : Explorer les types {.smaller} + +**Demandez au LLM :** + +> "Explique-moi les différents types de données en R avec des exemples simples." + +**Ensuite, testez ce code et observez :** + +```{r} +#| eval: false +nombre <- 42 +texte <- "Hello" +vrai_faux <- TRUE + +class(nombre) +class(texte) +class(vrai_faux) +``` + +::: {.fragment} +**Question bonus :** Que se passe-t-il si on essaie d'additionner un nombre et du texte ? +::: + +::: {.notes} +15 minutes. Concept important. Les erreurs de type sont fréquentes pour les débutants. +::: + +## Les vecteurs + +Un **vecteur** est une collection de valeurs du même type. + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +prenoms <- c("Alice", "Bob", "Charlie") +``` + +::: {.fragment} +::: {.callout-note} +## Important +`c()` signifie "**c**ombine" - elle regroupe plusieurs valeurs. +::: +::: + +## Exercice 6 : Manipuler des vecteurs {.smaller} + +**Créez un vecteur avec les températures de la semaine :** + +```{r} +#| eval: false +temperatures <- c(18, 20, 19, 22, 21, 17, 16) +``` + +**Demandez au LLM comment :** + +1. Afficher la première température +2. Afficher les trois premières températures +3. Calculer la température moyenne +4. Trouver la température maximale + +::: {.fragment} +**Testez les solutions proposées !** +::: + +::: {.notes} +15 minutes. Introduction à l'indexation. Les étudiants découvriront [1], [1:3], max(), etc. +::: + +# Fonctions intégrées {background-color="#DC143C"} + +## Qu'est-ce qu'une fonction ? + +Une **fonction** est un outil qui prend des données en entrée et produit un résultat. + +::: {.fragment} +**Analogie :** Une fonction est comme une machine : + +- Vous lui donnez quelque chose (l'**entrée**) +- Elle effectue une opération +- Elle vous rend un résultat (la **sortie**) +::: + +## Exercice 7 : Découvrir des fonctions {.smaller} + +**Avec votre vecteur de températures, testez :** + +```{r} +#| eval: false +temperatures <- c(18, 20, 19, 22, 21, 17, 16) + +mean(temperatures) # moyenne +sum(temperatures) # somme +length(temperatures) # nombre d'éléments +min(temperatures) # minimum +max(temperatures) # maximum +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Quelles autres fonctions statistiques utiles existent en R pour analyser un vecteur de nombres ?" +::: + +::: {.notes} +15 minutes. Les étudiants découvrent les fonctions intégrées. Encourager l'exploration. +::: + +## Exercice 8 : L'aide en R {.smaller} + +Vous pouvez obtenir de l'aide sur n'importe quelle fonction avec `?` : + +```{r} +#| eval: false +?mean +?sum +``` + +::: {.fragment} +**Explorez :** + +1. Testez `?mean` dans la console +2. Où apparaît l'aide ? +3. Que signifie le paramètre `na.rm` ? +::: + +::: {.fragment} +::: {.callout-tip} +## Double source d'aide +- L'aide R (documentation officielle) +- Les LLMs (explications en langage naturel) + +**Utilisez les deux !** +::: +::: + +::: {.notes} +15 minutes. Concept important : devenir autonome. L'aide R est technique mais précise. +::: + +## Exercice 9 : Gérer les valeurs manquantes {.smaller} + +**Testez ce code :** + +```{r} +#| eval: false +notes_avec_absence <- c(12, 15, NA, 13, 8) +mean(notes_avec_absence) +``` + +::: {.fragment} +**Que se passe-t-il ?** + +`NA` signifie "**N**ot **A**vailable" (donnée manquante). +::: + +::: {.fragment} +**Demandez au LLM comment calculer la moyenne en ignorant les NA.** + +*Indice : regardez dans l'aide de `mean()` le paramètre `na.rm`* +::: + +::: {.notes} +15 minutes. Problème réel et fréquent. Les étudiants découvrent na.rm = TRUE. +::: + +# Premier script {background-color="#2F4F4F"} + +## Pourquoi un script ? + +Jusqu'ici, vous avez tapé dans la **console** (code éphémère). + +::: {.fragment} +Un **script** permet de : + +- **Sauvegarder** votre code +- Le **réutiliser** +- Le **partager** +- Le **commenter** +::: + +## Exercice 10 : Créer un script {.smaller} + +1. Cliquez sur **File > New File > R Script** +2. Dans ce nouveau fichier, écrivez : + +```{r} +#| eval: false +# Mon premier script R +# Auteur : [Votre nom] + +# Calcul de moyennes +notes <- c(12, 15, 13, 8) +moyenne <- mean(notes) + +print("La moyenne est :") +print(moyenne) +``` + +3. **Sauvegardez** (File > Save ou Ctrl+S) +4. **Exécutez** ligne par ligne (Ctrl+Entrée) + +::: {.notes} +20 minutes. Première sauvegarde de code. Insister sur les commentaires (#). +::: + +## Les commentaires + +Les lignes commençant par `#` sont des **commentaires** : + +```{r} +#| eval: false +# Ceci est un commentaire - R l'ignore +notes <- c(12, 15, 13, 8) # Commentaire après du code +``` + +::: {.fragment} +::: {.callout-tip} +## Bonne pratique +Commentez votre code pour expliquer **pourquoi** vous faites quelque chose, pas seulement **ce que** vous faites. +::: +::: + +## Exercice 11 : Script complet {.smaller} + +**Créez un script qui :** + +1. Crée un vecteur de températures sur 7 jours +2. Calcule la moyenne, le minimum et le maximum +3. Affiche ces résultats avec `print()` +4. Commente chaque étape + +::: {.fragment} +**Demandez au LLM de vous aider si nécessaire, mais essayez d'abord par vous-même !** +::: + +::: {.notes} +20 minutes. Exercice de synthèse. Les étudiants combinent tout ce qu'ils ont appris. +::: + +# Journal de bord et réflexion {background-color="#2E8B57"} + +## Votre journal de bord + +::: {.callout-note} +## Outil essentiel +Tout au long de ce cours, vous tiendrez un **journal de bord** documentant votre apprentissage. +::: + +::: {.incremental} +**Pour chaque séance, notez :** + +1. Les **prompts** que vous avez utilisés avec les LLMs +2. Les **réponses** obtenues (copier-coller) +3. Ce que vous avez **compris** +4. Les **difficultés** rencontrées +5. Les **solutions** trouvées +::: + +## Exercice 12 : Première entrée du journal {.smaller} + +**Dans votre journal, répondez à :** + +1. **Qu'est-ce qu'un objet en R ?** (avec vos propres mots) +2. **Qu'est-ce qu'une fonction ?** (donnez 3 exemples) +3. **Un prompt efficace** que vous avez utilisé aujourd'hui +4. **Une erreur** que vous avez rencontrée et comment vous l'avez résolue +5. **Une question** que vous vous posez encore + +::: {.fragment} +::: {.callout-tip} +## Conseil +Soyez précis ! Plus votre journal est détaillé, plus il vous sera utile. +::: +::: + +::: {.notes} +20 minutes. Moment réflexif important. Circuler pour voir les journaux. Donner des retours. +::: + +## Conseils pour les prompts + +::: {.incremental} +**Un bon prompt :** + +- Est **précis** : "Explique-moi les vecteurs en R" plutôt que "Parle-moi de R" +- Donne du **contexte** : "Je débute en programmation" +- Demande des **exemples** : "Avec un exemple simple" +- Peut être **affiné** : Si la réponse ne convient pas, reformulez ! +::: + +## Exemples de bons prompts + +::: {.callout-tip} +## Exemples + +- "Je débute en R. Peux-tu m'expliquer ce que fait c() avec un exemple concret ?" +- "J'ai cette erreur [copier l'erreur]. Qu'est-ce que ça signifie et comment la corriger ?" +- "Comment calculer la moyenne d'un vecteur contenant des NA en R ?" +::: + +# Ressources et prochaines étapes {background-color="#4169E1"} + +## Ce que vous avez appris aujourd'hui + +::: {.incremental} +✅ Utiliser RStudio +✅ Créer des objets avec `<-` +✅ Manipuler des vecteurs avec `c()` +✅ Utiliser des fonctions : `mean()`, `sum()`, `max()`, etc. +✅ Écrire et sauvegarder un script +✅ Commenter son code +✅ Utiliser les LLMs comme assistants +::: + +## Pour aller plus loin + +::: {.incremental} +- **Pratiquez** : La programmation s'apprend en faisant +- **Expérimentez** : Testez des fonctions, cassez des choses ! +- **Documentez** : Tenez votre journal à jour +- **Demandez** : Aux LLMs, à vos camarades, à l'enseignant +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez les exercices si besoin +2. **Mettez à jour votre journal de bord** +3. Créez un script avec une petite analyse de votre choix (notes, prix, âges, etc.) +4. Explorez 2 nouvelles fonctions et documentez-les dans votre journal +::: + +## Questions ? + +::: {.callout-tip} +## N'oubliez pas + +- R est un **outil** - il faut du temps pour le maîtriser +- Les **erreurs sont normales** et font partie de l'apprentissage +- Les LLMs sont des **assistants**, pas des remplaçants de votre cerveau +- **Testez toujours** le code avant de l'utiliser +::: + +::: {.fragment} +**Bienvenue dans l'aventure R ! 🚀** +::: diff --git a/M3P/03Lecon2Donnees.qmd b/M3P/03Lecon2Donnees.qmd new file mode 100644 index 0000000..2919280 --- /dev/null +++ b/M3P/03Lecon2Donnees.qmd @@ -0,0 +1,719 @@ +--- +title: "Séance 2 : Données et fonctions intégrées" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon2.html + embed-resources: true + footer: "Séance 2 - Données et fonctions" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (20min) : Retours sur vos journaux +- **Charger des données** (45min) : Importer des fichiers CSV +- **Exploration de données** (45min) : Structure et types de données +- **Statistiques descriptives** (45min) : Analyser les données +- **Visualisations de base** (45min) : Créer des graphiques +- **Mini-projet** (50min) : Analyser des données réelles +::: + +::: {.fragment} +**Production attendue :** Analyse commentée de données avec graphiques +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Manipuler de vraies données +::: + +::: {.incremental} +- **Importer** des données depuis des fichiers +- **Explorer** la structure des données (data frames) +- Calculer des **statistiques descriptives** +- Créer des **visualisations** simples +- Gérer les **données manquantes** +- **Débugger** avec l'aide des LLMs +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur la séance 1 + +::: {.incremental} +- Qu'avez-vous retenu de la semaine dernière ? +- Quels concepts restent flous ? +- Avez-vous pratiqué entre les séances ? +::: + +## Retours sur vos journaux {.smaller} + +::: {.callout-note} +## Conseils pour améliorer vos journaux +::: + +::: {.incremental} +- **Copier-coller** les prompts exacts que vous utilisez +- **Documenter** les réponses du LLM (pas juste des captures d'écran) +- **Expliquer avec vos propres mots** ce que vous avez compris +- **Noter les erreurs** rencontrées et comment vous les avez résolues +- **Éviter** les formats propriétaires (.pages) - préférer .docx ou .pdf +::: + +::: {.notes} +10 minutes. Discuter des journaux. Montrer des exemples anonymisés (bons et moins bons). +::: + +## Exercice de révision {.smaller} + +**Sans utiliser le LLM, écrivez un script qui :** + +1. Crée un vecteur avec 5 nombres de votre choix +2. Calcule la moyenne +3. Trouve le maximum +4. Affiche les résultats avec `print()` + +::: {.fragment} +**Ensuite, comparez avec votre voisin et discutez des différences.** +::: + +::: {.notes} +10 minutes. Révision active. Encourage la discussion entre étudiants. +::: + +# Charger des données {background-color="#4169E1"} + +## Des vecteurs aux données réelles + +Jusqu'ici, vous avez créé des données avec `c()` : + +```{r} +#| eval: false +notes <- c(12, 15, 13, 8) +``` + +::: {.fragment} +**Dans la vraie vie**, les données viennent souvent de fichiers : CSV, Excel, bases de données, etc. +::: + +## Le format CSV + +::: {.callout-note} +## CSV = Comma Separated Values +Un format simple et universel pour stocker des données tabulaires. +::: + +::: {.fragment} +**Exemple de contenu CSV :** + +``` +nom,age,note +Alice,20,15 +Bob,22,12 +Charlie,21,14 +``` +::: + +## Exercice 1 : Télécharger les données {.smaller} + +1. Connectez-vous sur Moodle +2. Téléchargez le fichier `donnees_meteo.csv` +3. Placez-le dans votre dossier de travail + +::: {.fragment} +**Comment connaître votre dossier de travail ?** + +```{r} +#| eval: false +getwd() # "get working directory" +``` +::: + +::: {.fragment} +**Pour le changer :** + +```{r} +#| eval: false +setwd("/chemin/vers/votre/dossier") +``` + +Ou utilisez **Session > Set Working Directory** dans RStudio. +::: + +::: {.notes} +10 minutes. S'assurer que tout le monde a les données au bon endroit. Circuler pour aider. +::: + +## Exercice 2 : Importer les données {.smaller} + +**Demandez à votre LLM :** + +> "Comment importer un fichier CSV en R ? Je débute en programmation." + +::: {.fragment} +Vous devriez obtenir quelque chose comme : + +```{r} +#| eval: false +donnees_meteo <- read.csv("donnees_meteo.csv") +``` +::: + +::: {.fragment} +**Testez cette commande !** + +En cas d'erreur, demandez au LLM de vous aider à débugger. +::: + +::: {.notes} +15 minutes. Première importation de données. Anticiper les erreurs de chemin, d'encodage, etc. +::: + +## Vérifier l'importation + +Une fois importé, vérifiez que ça a fonctionné : + +```{r} +#| eval: false +# Afficher les premières lignes +head(donnees_meteo) + +# Afficher la structure +str(donnees_meteo) +``` + +::: {.fragment} +**Demandez au LLM d'expliquer ce que montrent ces fonctions.** +::: + +# Exploration de données {background-color="#FF8C00"} + +## Les data frames + +Les données importées sont stockées dans un **data frame**. + +::: {.fragment} +::: {.callout-tip} +## Analogie +Un data frame est comme un tableau Excel : des lignes (observations) et des colonnes (variables). +::: +::: + +## Exercice 3 : Explorer la structure {.smaller} + +**Avec vos données météo, testez :** + +```{r} +#| eval: false +# Nombre de lignes et colonnes +nrow(donnees_meteo) +ncol(donnees_meteo) +dim(donnees_meteo) # les deux à la fois + +# Noms des colonnes +names(donnees_meteo) +colnames(donnees_meteo) + +# Résumé rapide +summary(donnees_meteo) +``` + +::: {.fragment} +**Questions :** + +1. Combien d'observations avez-vous ? +2. Quelles variables (colonnes) sont présentes ? +3. Quel type de données contient chaque colonne ? +::: + +::: {.notes} +15 minutes. Découverte des fonctions d'exploration. Essentielles pour comprendre les données. +::: + +## Accéder aux colonnes + +Pour accéder à une colonne spécifique, utilisez `$` : + +```{r} +#| eval: false +donnees_meteo$temperature +donnees_meteo$date +``` + +::: {.fragment} +**Cela retourne un vecteur !** Vous pouvez donc utiliser toutes les fonctions que vous connaissez : + +```{r} +#| eval: false +mean(donnees_meteo$temperature) +max(donnees_meteo$temperature) +``` +::: + +## Exercice 4 : Analyser les variables {.smaller} + +**Pour chaque variable numérique dans vos données, calculez :** + +1. La moyenne +2. La médiane +3. Le minimum +4. Le maximum +5. L'écart-type (`sd()`) + +::: {.fragment} +**Demandez au LLM :** + +> "Comment calculer des statistiques descriptives sur une colonne d'un data frame en R ?" +::: + +::: {.fragment} +**Notez vos résultats dans un commentaire de votre script.** +::: + +::: {.notes} +15 minutes. Application pratique. Les étudiants utilisent $ et les fonctions statistiques. +::: + +# Statistiques descriptives {background-color="#8B008B"} + +## La fonction `summary()` + +`summary()` donne un aperçu rapide : + +```{r} +#| eval: false +summary(donnees_meteo$temperature) +``` + +::: {.fragment} +Elle affiche : + +- Minimum et maximum +- 1er quartile, médiane, 3e quartile +- Moyenne +::: + +## Exercice 5 : Comparer avec vos calculs {.smaller} + +**Comparez vos calculs précédents avec `summary()` :** + +```{r} +#| eval: false +# Vos calculs +mean(donnees_meteo$temperature) +median(donnees_meteo$temperature) +min(donnees_meteo$temperature) +max(donnees_meteo$temperature) + +# Summary +summary(donnees_meteo$temperature) +``` + +::: {.fragment} +**Questions :** + +1. Les résultats correspondent-ils ? +2. Que signifie "médiane" ? (Demandez au LLM si vous ne savez pas) +3. Que signifient les quartiles ? +::: + +::: {.notes} +15 minutes. Vérification et approfondissement. Introduction aux quartiles. +::: + +## Gérer les valeurs manquantes (NA) {.smaller} + +**Testez ce code :** + +```{r} +#| eval: false +# Y a-t-il des NA dans vos données ? +sum(is.na(donnees_meteo$temperature)) + +# Afficher les lignes avec des NA +donnees_meteo[is.na(donnees_meteo$temperature), ] +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Comment gérer les valeurs manquantes (NA) lors du calcul de statistiques en R ?" +::: + +::: {.fragment} +Vous découvrirez le paramètre `na.rm = TRUE` : + +```{r} +#| eval: false +mean(donnees_meteo$temperature, na.rm = TRUE) +``` +::: + +::: {.notes} +15 minutes. Problème réel très fréquent. Important de comprendre na.rm. +::: + +## Exercice 6 : Rapport statistique {.smaller} + +**Créez un script qui génère un rapport complet sur la variable température :** + +```{r} +#| eval: false +# Rapport sur la température +print("=== ANALYSE DE LA TEMPÉRATURE ===") +print(paste("Nombre d'observations :", length(donnees_meteo$temperature))) +print(paste("Valeurs manquantes :", sum(is.na(donnees_meteo$temperature)))) +print(paste("Moyenne :", mean(donnees_meteo$temperature, na.rm = TRUE))) +print(paste("Médiane :", median(donnees_meteo$temperature, na.rm = TRUE))) +print(paste("Écart-type :", sd(donnees_meteo$temperature, na.rm = TRUE))) +``` + +::: {.fragment} +**Extension :** Faites la même chose pour une autre variable. +::: + +::: {.notes} +15 minutes. Exercice de synthèse. Introduction à paste() pour formater. +::: + +# Visualisations {background-color="#DC143C"} + +## Pourquoi visualiser ? + +::: {.incremental} +- Les chiffres ne suffisent pas toujours +- Un graphique révèle des **patterns** invisibles dans les tableaux +- Communiquer plus efficacement +::: + +## Exercice 7 : Premier graphique {.smaller} + +**Demandez au LLM :** + +> "Comment créer un graphique simple en R pour visualiser l'évolution d'une variable dans le temps ? Je débute." + +::: {.fragment} +Vous découvrirez probablement `plot()` : + +```{r} +#| eval: false +plot(donnees_meteo$date, donnees_meteo$temperature) +``` +::: + +::: {.fragment} +**Testez ce code !** + +Si vous avez une erreur avec les dates, demandez au LLM comment les convertir au bon format. +::: + +::: {.notes} +15 minutes. Premier graphique. Les dates peuvent poser problème - bon exercice de debugging. +::: + +## Améliorer le graphique {.smaller} + +Les graphiques de base peuvent être personnalisés : + +```{r} +#| eval: false +plot(donnees_meteo$date, donnees_meteo$temperature, + type = "l", # ligne au lieu de points + col = "blue", + main = "Évolution de la température", + xlab = "Date", + ylab = "Température (°C)") +``` + +::: {.fragment} +**Demandez au LLM d'expliquer chaque paramètre.** +::: + +## Exercice 8 : Explorer d'autres graphiques {.smaller} + +**Demandez au LLM comment créer :** + +1. Un histogramme de la température +2. Un boxplot (boîte à moustaches) +3. Un graphique de points (scatter plot) si vous avez deux variables numériques + +::: {.fragment} +**Testez chaque type et notez dans votre journal :** + +- La commande utilisée +- Ce que montre le graphique +- Quand l'utiliser +::: + +::: {.notes} +20 minutes. Exploration des types de graphiques. Encourager la curiosité. +::: + +## Sauvegarder un graphique + +Pour sauvegarder un graphique : + +```{r} +#| eval: false +# Ouvrir un fichier +png("mon_graphique.png", width = 800, height = 600) + +# Créer le graphique +plot(donnees_meteo$date, donnees_meteo$temperature, type = "l") + +# Fermer le fichier +dev.off() +``` + +::: {.fragment} +Le fichier sera dans votre dossier de travail. +::: + +# Debugging {background-color="#2F4F4F"} + +## Les erreurs sont normales ! + +::: {.callout-warning} +## Important +Tout le monde rencontre des erreurs. C'est une partie essentielle de la programmation. +::: + +::: {.fragment} +**Stratégie de debugging :** + +1. **Lire** le message d'erreur (même s'il semble cryptique) +2. **Identifier** la ligne problématique +3. **Tester** des hypothèses +4. **Demander** de l'aide (LLM, documentation, pairs) +::: + +## Exercice 9 : Debugging collectif {.smaller} + +**Voici du code avec des erreurs. Trouvez-les et corrigez-les :** + +```{r} +#| eval: false +# Charger les données +donnees <- read.csv(donnees_meteo.csv) + +# Calculer la moyenne +moyenne_temp <- mean(donnees$Temperature) + +# Afficher +print("La moyenne est" moyenne_temp) +``` + +::: {.fragment} +**Travaillez par groupes de 2-3. Utilisez le LLM si nécessaire.** +::: + +::: {.fragment} +**Erreurs à trouver :** + +1. Guillemets manquants autour du nom de fichier +2. Majuscule incorrecte dans le nom de colonne +3. Virgule manquante dans `print()` +::: + +::: {.notes} +15 minutes. Exercice collectif. Discuter ensuite des types d'erreurs courantes. +::: + +## Bien utiliser le LLM pour débugger {.smaller} + +::: {.callout-tip} +## Comment demander de l'aide efficacement +::: + +**Mauvais prompt :** +> "Ça marche pas" + +**Bon prompt :** +> "J'essaie d'importer un fichier CSV avec read.csv() mais j'obtiens cette erreur : [copier l'erreur exacte]. Voici mon code : [copier le code]. Que dois-je corriger ?" + +::: {.fragment} +**Donnez toujours :** + +- Le code exact +- L'erreur complète +- Ce que vous essayez de faire +- Votre niveau (débutant) +::: + +# Mini-projet {background-color="#2E8B57"} + +## Projet : Analyse de données INSEE {.smaller} + +**Objectif :** Analyser des données économiques réelles. + +**Étapes :** + +1. Allez sur +2. Téléchargez les données du PIB (format CSV de préférence) +3. Importez-les dans R +4. Créez un rapport complet + +::: {.callout-note} +## Rapport attendu +- Import et vérification des données +- Statistiques descriptives +- Au moins 2 graphiques +- Commentaires expliquant vos observations +::: + +::: {.notes} +50 minutes. Projet autonome. Circuler beaucoup. Les étudiants vont rencontrer des difficultés (format de données, etc.) - c'est normal et formateur. +::: + +## Critères du mini-projet {.smaller} + +Votre analyse doit inclure : + +::: {.incremental} +- ✅ Import réussi des données +- ✅ Exploration de la structure (`str()`, `summary()`, etc.) +- ✅ Au moins 5 statistiques descriptives calculées +- ✅ Au moins 2 visualisations différentes +- ✅ Code commenté et organisé +- ✅ Interprétation des résultats (commentaires en français) +::: + +::: {.fragment} +**Bonus :** + +- Gestion des NA +- Graphiques personnalisés +- Comparaison entre plusieurs variables +::: + +## Aide pour le projet {.smaller} + +**Si vous êtes bloqué :** + +1. Relisez les exercices précédents +2. Consultez votre journal +3. Demandez à votre voisin +4. Utilisez le LLM avec un prompt précis +5. Appelez l'enseignant + +::: {.fragment} +::: {.callout-tip} +## Conseil +Procédez par étapes. Testez chaque ligne avant de passer à la suivante. +::: +::: + +# Retour réflexif {background-color="#4169E1"} + +## Exercice de synthèse : Journal de bord {.smaller} + +**Dans votre journal, documentez :** + +1. **Import de données** : + - Prompts utilisés pour apprendre à importer + - Difficultés rencontrées (chemins, formats, etc.) + - Solutions trouvées + +2. **Analyse et visualisation** : + - 3 fonctions nouvelles que vous maîtrisez maintenant + - Un graphique dont vous êtes fier (copier le code) + - Une chose que vous ne comprenez pas encore + +3. **Debugging** : + - Une erreur marquante et comment vous l'avez résolue + - Un bon prompt de debugging qui a fonctionné + +::: {.notes} +15 minutes. Temps de réflexion calme. Important pour ancrer les apprentissages. +::: + +## Évolution de vos compétences + +::: {.incremental} +**Séance 1 :** Vous avez appris les bases (objets, fonctions, vecteurs) + +**Séance 2 :** Vous savez maintenant : + +- Importer des données réelles +- Les explorer et les analyser +- Créer des visualisations +- Débugger efficacement +::: + +::: {.fragment} +**Vous êtes déjà capable d'analyser de vraies données ! 🎉** +::: + +# Ressources et prochaines étapes {background-color="#8B008B"} + +## Fonctions clés de cette séance + +::: {.incremental} +**Import et exploration :** + +- `read.csv()`, `getwd()`, `setwd()` +- `head()`, `str()`, `summary()`, `dim()`, `names()` + +**Statistiques :** + +- `mean()`, `median()`, `sd()`, `min()`, `max()` +- `na.rm = TRUE` pour gérer les NA + +**Visualisation :** + +- `plot()`, `hist()`, `boxplot()` +- Paramètres : `type`, `col`, `main`, `xlab`, `ylab` +::: + +## Pour aller plus loin + +::: {.incremental} +- **Pratiquez** avec d'autres jeux de données +- **Explorez** d'autres types de graphiques +- **Découvrez** le package `ggplot2` (pour plus tard) +- **Partagez** vos visualisations avec vos camarades +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez le mini-projet INSEE si besoin +2. **Mettez à jour votre journal** avec tous les détails de cette séance +3. Trouvez un jeu de données qui vous intéresse et analysez-le +4. Créez au moins 3 graphiques différents avec vos données +::: + +::: {.fragment} +**Prochaine séance :** Fonctions, conditions et boucles - automatiser vos analyses ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Les **data frames** sont essentiels pour travailler avec des données réelles +- `$` permet d'accéder aux colonnes +- Toujours vérifier les **NA** avant de calculer +- Les **visualisations** révèlent ce que les chiffres cachent +- Le **debugging** fait partie du processus - soyez patient ! +::: + +::: {.fragment} +**Bon courage et bonnes analyses ! 📊** +::: + diff --git a/M3P/04Lecon3Fonctions.qmd b/M3P/04Lecon3Fonctions.qmd new file mode 100644 index 0000000..d672252 --- /dev/null +++ b/M3P/04Lecon3Fonctions.qmd @@ -0,0 +1,477 @@ +--- +title: "Séance 3 : Fonctions, conditions et boucles" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon3.html + embed-resources: true + footer: "Séance 3 - Fonctions, conditions et boucles" +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur les données +- **Conditions if/else** (45min) : Prendre des décisions dans le code +- **Boucles** (45min) : Répéter des opérations +- **Créer ses propres fonctions** (60min) : Structurer son code +- **Mini-projet** (45min) : Analyser des données avec vos fonctions +::: + +::: {.fragment} +**Production attendue :** 3 fonctions personnalisées avec conditions et/ou boucles +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Automatiser et structurer son code +::: + +::: {.incremental} +- Utiliser des **conditions** pour adapter le comportement du code +- Utiliser des **boucles** pour répéter des opérations +- **Créer des fonctions** réutilisables +- **Combiner** ces concepts pour résoudre des problèmes réels +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur vos analyses de données + +::: {.incremental} +- Quelles difficultés avez-vous rencontrées ? +- Quelles fonctions intégrées avez-vous découvertes ? +- Comment les LLMs vous ont-ils aidé ? +::: + +# Conditions if/else {background-color="#4169E1"} + +## Pourquoi des conditions ? + +::: {.callout-note} +## Question +Imaginez que vous analysez des températures. Comment indiquer s'il fait chaud ou froid ? +::: + +::: {.fragment} +On a besoin de **tester une condition** et agir différemment selon le résultat. +::: + +## Exercice 1 : Première condition {.smaller} + +Demandez à votre LLM de vous expliquer la structure `if/else` en R avec un exemple simple. + +**Ensuite, testez ce code :** + +```{r} +#| eval: false +temperature <- 25 + +if (temperature > 20) { + print("Il fait chaud") +} +``` + +**Questions à explorer avec votre LLM :** + +1. Que se passe-t-il si `temperature <- 15` ? +2. Comment ajouter un message pour "Il fait froid" ? +3. Qu'est-ce qu'un opérateur de comparaison ? (`>`, `<`, `==`, `!=`, `>=`, `<=`) + +::: {.notes} +Laisser 10 minutes. Circuler pour vérifier la compréhension. Insister sur le fait que le LLM peut se tromper - tester le code est essentiel. +::: + +## Exercice 2 : if/else complet {.smaller} + +Créez un code qui : + +- Prend une note (0-20) +- Affiche "Réussite" si la note est >= 10 +- Affiche "Échec" sinon + +::: {.fragment} +**Extension :** Ajoutez une troisième catégorie avec `else if` : + +- "Excellent" si >= 16 +- "Réussite" si >= 10 +- "Échec" sinon +::: + +::: {.notes} +10 minutes. Faire un débriefing collectif. Demander à un étudiant de partager son code et son prompt. +::: + +## Exercice 3 : Conditions et vecteurs {.smaller} + +**Problème :** Vous avez plusieurs notes : + +```{r} +#| eval: false +notes <- c(8, 12, 15, 9, 18) +``` + +**Question :** Comment classifier TOUTES ces notes ? + +Demandez à votre LLM comment appliquer une condition à un vecteur. + +::: {.fragment} +**Indices à explorer :** + +- La fonction `ifelse()` +- La différence entre `if` et `ifelse()` +::: + +::: {.notes} +15 minutes. C'est un concept important. Les étudiants découvriront la vectorisation. Certains LLMs proposeront des boucles, d'autres `ifelse()`. Discuter les deux approches. +::: + +# Boucles {background-color="#FF8C00"} + +## Pourquoi des boucles ? + +::: {.callout-note} +## Situation +Vous avez 100 températures à classifier. Écrire 100 fois `if/else` ? +::: + +::: {.fragment} +Les **boucles** permettent de répéter automatiquement des opérations. +::: + +## Exercice 4 : Boucle for simple {.smaller} + +Demandez à votre LLM d'expliquer la boucle `for` en R avec un exemple. + +**Testez ce code :** + +```{r} +#| eval: false +for (i in 1:5) { + print(i) +} +``` + +**Questions :** + +1. Que fait `1:5` ? +2. Que représente `i` ? +3. Comment afficher les nombres de 10 à 20 ? + +::: {.notes} +10 minutes. Concept fondamental mais peut être abstrait pour certains. +::: + +## Exercice 5 : Boucle sur un vecteur {.smaller} + +Reprenez vos notes de l'exercice 3 : + +```{r} +#| eval: false +notes <- c(8, 12, 15, 9, 18) +``` + +Utilisez une boucle `for` pour : + +1. Afficher chaque note +2. Afficher chaque note avec son classement (Réussite/Échec) + +::: {.fragment} +**Astuce :** Combinez `for` et `if/else` ! +::: + +::: {.notes} +15 minutes. Les étudiants vont combiner les deux concepts. Anticiper les confusions entre i (indice) et notes[i] (valeur). +::: + +## Exercice 6 : Accumuler des résultats {.smaller} + +**Nouveau défi :** Calculez la somme des notes **sans utiliser** `sum()`. + +**Indices :** + +1. Créez une variable `total <- 0` +2. Utilisez une boucle pour ajouter chaque note à `total` +3. Affichez le résultat final + +::: {.fragment} +**Vérification :** Comparez avec `sum(notes)` +::: + +::: {.notes} +10 minutes. Introduit le concept d'accumulation. Utile pour comprendre ce que font réellement les fonctions intégrées. +::: + +## Boucle while (optionnel) {.smaller} + +Demandez à votre LLM la différence entre `for` et `while`. + +**Exemple à tester :** + +```{r} +#| eval: false +compteur <- 1 +while (compteur <= 5) { + print(compteur) + compteur <- compteur + 1 +} +``` + +::: {.callout-warning} +## Attention ! +Que se passe-t-il si vous oubliez `compteur <- compteur + 1` ? +::: + +::: {.notes} +Optionnel car `while` est moins utilisé en R. Mais bon pour comprendre les concepts de programmation. Attention aux boucles infinies ! +::: + +# Créer ses fonctions {background-color="#8B008B"} + +## Pourquoi créer des fonctions ? + +Jusqu'ici, vous avez **utilisé** des fonctions : `mean()`, `sum()`, `print()`... + +::: {.fragment} +Maintenant, vous allez **créer** vos propres fonctions ! +::: + +::: {.fragment} +::: {.callout-tip} +## Avantages +- Réutiliser du code +- Éviter la répétition +- Rendre le code plus lisible +- Partager avec d'autres +::: +::: + +## Exercice 7 : Première fonction {.smaller} + +Demandez à votre LLM d'expliquer comment créer une fonction en R. + +**Créez une fonction simple :** + +```{r} +#| eval: false +dire_bonjour <- function(nom) { + message <- paste("Bonjour", nom) + return(message) +} + +# Test +dire_bonjour("Alice") +``` + +**Questions :** + +1. À quoi sert `function()` ? +2. Qu'est-ce qu'un **paramètre** / **argument** ? +3. À quoi sert `return()` ? + +::: {.notes} +15 minutes. Première fonction. Bien distinguer définition (function) et appel (dire_bonjour("Alice")). +::: + +## Exercice 8 : Fonction avec condition {.smaller} + +Créez une fonction `classifier_note()` qui : + +- Prend une note en paramètre +- Retourne "Excellent" si >= 16 +- Retourne "Réussite" si >= 10 +- Retourne "Échec" sinon + +**Testez avec plusieurs valeurs.** + +::: {.fragment} +**Extension :** Que se passe-t-il si on passe une note négative ou > 20 ? Comment améliorer la fonction ? +::: + +::: {.notes} +15 minutes. Première fonction "utile". L'extension introduit la validation des paramètres (concept important). +::: + +## Exercice 9 : Fonction avec boucle {.smaller} + +Créez une fonction `calculer_moyenne()` qui : + +- Prend un vecteur de nombres +- Utilise une boucle pour calculer la moyenne +- Retourne le résultat + +**Testez :** + +```{r} +#| eval: false +mes_notes <- c(12, 15, 8, 14) +calculer_moyenne(mes_notes) +``` + +::: {.fragment} +**Questions :** + +1. Comment gérer les valeurs manquantes (`NA`) ? +2. Comparez votre résultat avec `mean()` +::: + +::: {.notes} +15 minutes. Fonction plus complexe. Les étudiants réutilisent l'exercice 6. Discussion sur NA importante. +::: + +## Exercice 10 : Fonction complète {.smaller} + +Créez une fonction `analyser_vecteur()` qui prend un vecteur et retourne : + +- Le minimum +- Le maximum +- La moyenne +- Le nombre d'éléments + +::: {.fragment} +**Défi :** Comment retourner plusieurs valeurs ? Demandez au LLM ! + +*Indice : liste ou vecteur nommé* +::: + +::: {.notes} +15 minutes. Fonction avancée. Introduit le concept de retourner des structures de données complexes. Les étudiants découvriront les listes. +::: + +# Mini-projet {background-color="#DC143C"} + +## Projet : Analyse de températures {.smaller} + +Vous allez créer un petit système d'analyse météo. + +**Données :** + +```{r} +#| eval: false +temperatures <- c(15, 22, 18, 25, 12, 28, 20, 16, 24, 19) +``` + +**Créez les fonctions suivantes :** + +1. `classifier_temperature(temp)` : retourne "Froid", "Doux" ou "Chaud" +2. `compter_par_categorie(vecteur_temp)` : compte combien de jours froids/doux/chauds +3. `rapport_meteo(vecteur_temp)` : génère un rapport complet (min, max, moyenne, catégories) + +::: {.callout-note} +## Utilisez tout ce que vous avez appris +Conditions, boucles, fonctions ! +::: + +::: {.notes} +45 minutes. Projet synthèse. Les étudiants combinent tous les concepts. Circuler beaucoup. Encourager l'aide entre pairs. Certains iront plus loin (graphiques, etc.). +::: + +## Critères du mini-projet {.smaller} + +Votre code doit : + +::: {.incremental} +- ✅ Fonctionner sans erreur +- ✅ Contenir au moins 3 fonctions +- ✅ Utiliser des conditions (`if/else`) +- ✅ Utiliser au moins une boucle +- ✅ Être commenté (expliquez ce que fait chaque fonction) +::: + +::: {.fragment} +**Bonus :** + +- Gérer les cas d'erreur (NA, vecteur vide, etc.) +- Créer des visualisations +- Tester avec d'autres données +::: + +::: {.notes} +Afficher les critères clairement. Certains étudiants auront besoin de plus de temps - c'est OK. +::: + +# Retour sur l'utilisation des LLMs {background-color="#2F4F4F"} + +## Pièges courants avec les LLMs + +::: {.callout-warning} +## Attention ! +Les LLMs peuvent : + +- Proposer du code qui ne fonctionne pas +- Utiliser des fonctions qui n'existent pas +- Mélanger différentes versions de R +- Donner des explications approximatives +::: + +::: {.fragment} +**Votre responsabilité :** TOUJOURS tester le code ! +::: + +## Exercice réflexif : Journal de bord {.smaller} + +Dans votre journal, documentez : + +1. **Un prompt qui a bien fonctionné** : Pourquoi ? +2. **Une erreur du LLM** : Comment l'avez-vous détectée ? Corrigée ? +3. **Votre code le plus complexe** : Expliquez-le avec vos mots +4. **Une chose que vous ne comprenez pas encore** : À approfondir + +::: {.fragment} +::: {.callout-tip} +## Conseil +Plus vous serez précis dans vos prompts, meilleures seront les réponses. Donnez du contexte ! +::: +::: + +::: {.notes} +10 dernières minutes. Moment réflexif important. Les étudiants prennent du recul sur leur apprentissage. +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Pour aller plus loin + +::: {.incremental} +- **Documentation R :** `?function`, `?if`, `?for` +- **Pratiquez :** La programmation s'apprend en codant ! +- **Debuggez :** Les erreurs sont normales et instructives +- **Partagez :** Discutez de vos solutions avec vos pairs +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs +1. Terminez le mini-projet si besoin +2. Mettez à jour votre journal de bord +3. Créez au moins une fonction originale qui vous serait utile +::: + +::: {.fragment} +**Questions à explorer :** Comment sauvegarder ses fonctions ? Comment les partager ? (→ scripts, packages) +::: + +## Questions ? + +::: {.callout-tip} +## N'oubliez pas +- Testez votre code +- Commentez votre code +- Documentez votre apprentissage +- Utilisez les LLMs comme **assistants**, pas comme **rédacteurs** +::: + +::: {.fragment} +**Bon courage et bon code ! 🚀** +::: \ No newline at end of file diff --git a/M3P/05Lecon4Dataframes.qmd b/M3P/05Lecon4Dataframes.qmd new file mode 100644 index 0000000..c1b4a00 --- /dev/null +++ b/M3P/05Lecon4Dataframes.qmd @@ -0,0 +1,574 @@ +--- +title: "Séance 4 : Données tabulaires et graphiques avancés" +subtitle: "Apprendre R avec les LLMs" +author: "Elias Bouacida" +date: last-modified +date-format: long +format: + html: default + revealjs: + scrollable: true + slide-number: true + output-file: slide-lecon4.html + embed-resources: true + footer: "Séance 4 - Données tabulaires et graphiques avancés" +format-links: [revealjs] +lang: fr +execute: + echo: true +--- + +## Plan de la séance {.smaller} + +::: {.incremental} +- **Récap et partage** (15min) : Retours sur les fonctions +- **Nettoyage de données** (60min) : Gérer les incohérences réelles +- **Introduction à ggplot2** (75min) : Créer des graphiques sophistiqués +- **Fonctions de visualisation** (40min) : Automatiser la création de graphiques +- **Mini-projet** (40min) : Dashboard de visualisations +::: + +::: {.fragment} +**Production attendue :** Dashboard avec 4 graphiques + fonction de visualisation réutilisable +::: + +## Objectifs de la séance + +::: {.callout-tip} +## Maîtriser les données complexes et la visualisation +::: + +::: {.incremental} +- **Nettoyer** des données avec incohérences (casse, formats) +- Maîtriser les **dataframes** avancés +- Créer des **visualisations** avec ggplot2 +- Développer des **fonctions graphiques** réutilisables +- Combiner analyse et communication visuelle +::: + +# Récap et partage {background-color="#2E8B57"} + +## Retours sur les fonctions + +::: {.incremental} +- Quelles fonctions avez-vous créées ? +- Quelles difficultés avec les conditions et boucles ? +- Un exemple de bug intéressant que vous avez résolu ? +::: + +## Exercice de révision {.smaller} + +**Créez rapidement une fonction qui :** + +1. Prend un vecteur de nombres en paramètre +2. Retourne "Positif" si la moyenne est > 0 +3. Retourne "Négatif" sinon +4. Gère les NA correctement + +::: {.fragment} +**Testez avec :** + +```{r} +#| eval: false +valeurs <- c(-5, 10, NA, 8, -3) +classifier_moyenne(valeurs) +``` +::: + +::: {.notes} +10 minutes. Révision rapide. Vérifier que les concepts de la séance 3 sont acquis. +::: + +# Données réelles et leurs problèmes {background-color="#4169E1"} + +## Les données ne sont jamais parfaites + +Dans le monde réel, les données contiennent souvent : + +::: {.incremental} +- Des **problèmes de casse** : "Alice", "alice", "ALICE" +- Des **formats incohérents** : "2023-01-15", "15/01/2023" +- Des **valeurs manquantes** : NA, "", "N/A", "inconnu" +- Des **doublons** +- Des **erreurs de saisie** +::: + +::: {.fragment} +::: {.callout-warning} +## Important +Le nettoyage des données représente souvent 80% du travail d'analyse ! +::: +::: + +## Exercice 1 : Découvrir les problèmes {.smaller} + +**Voici un jeu de données de ventes :** + +```{r} +#| eval: false +ventes <- data.frame( + mois = c("Jan", "Fév", "Mar", "Avr", "Mai", "Jun"), + montant = c(1500, 2000, NA, 1800, 2200, 1900), + vendeur = c("Alice", "Bob", "alice", "Bob", "Alice", "bob") +) +``` + +**Demandez au LLM :** + +> "Quels sont les problèmes potentiels dans ce jeu de données pour une analyse ?" + +::: {.fragment} +**Identifiez :** + +1. Le problème de casse dans les noms +2. La valeur manquante +3. Les conséquences pour les calculs par vendeur +::: + +::: {.notes} +15 minutes. Les étudiants découvrent les problèmes réels des données. +::: + +## Exercice 2 : Nettoyer la casse {.smaller} + +**Problème :** Les noms "Alice", "alice" et "Bob", "bob" sont comptés séparément. + +**Demandez au LLM comment standardiser les noms.** + +::: {.fragment} +Vous découvrirez probablement : + +```{r} +#| eval: false +ventes$vendeur <- tolower(ventes$vendeur) +# ou +ventes$vendeur <- toupper(ventes$vendeur) +``` +::: + +::: {.fragment} +**Vérifiez le résultat :** + +```{r} +#| eval: false +unique(ventes$vendeur) +table(ventes$vendeur) +``` +::: + +::: {.notes} +15 minutes. Premier nettoyage simple mais essentiel. +::: + +## Exercice 3 : Gérer les valeurs manquantes {.smaller} + +**Plusieurs stratégies possibles :** + +**Demandez au LLM :** + +> "Comment gérer les valeurs NA dans mes données de ventes ? Quelles sont les différentes approches ?" + +::: {.fragment} +**Options principales :** + +1. **Supprimer** les lignes avec NA : `na.omit()` +2. **Remplacer** par une valeur : moyenne, médiane, 0 +3. **Garder** mais utiliser `na.rm = TRUE` dans les calculs +::: + +::: {.fragment} +::: {.callout-note} +## Réflexion importante +Quelle stratégie choisir dépend du contexte ! Supprimer des données peut introduire des biais. +::: +::: + +::: {.notes} +15 minutes. Discussion importante sur les choix méthodologiques. +::: + +## Exercice 4 : Dataset complexe piégé {.smaller} + +**Nouveau challenge - Données étudiants :** + +```{r} +#| eval: false +etudiants <- data.frame( + nom = c("Dupont", "Martin", "Durand", "", "Petit"), + age = c(20, "vingt-deux", 19, 21, 18), + note_math = c(15, 12, NA, 16, 14), + note_info = c(13, NA, 15, 12, 16), + filiere = c("Info", "info", "Maths", "INFO", "maths") +) +``` + +**Mission :** + +1. Identifiez TOUS les problèmes +2. Nettoyez le dataset +3. Calculez la moyenne par filière + +::: {.fragment} +**Utilisez le LLM étape par étape !** +::: + +::: {.notes} +30 minutes. Exercice de synthèse sur le nettoyage. Beaucoup d'erreurs à trouver. +::: + +# Introduction à ggplot2 {background-color="#FF8C00"} + +## Pourquoi ggplot2 ? + +Jusqu'ici vous avez utilisé `plot()`, `hist()`, `barplot()`... + +::: {.fragment} +**ggplot2** est un package puissant pour créer des graphiques : + +- Syntaxe cohérente et logique +- Graphiques professionnels +- Très flexible et personnalisable +- Standard dans l'analyse de données en R +::: + +## La grammaire des graphiques + +**ggplot2** fonctionne par couches : + +::: {.incremental} +1. **Données** : `ggplot(data = mes_donnees)` +2. **Esthétiques** : `aes(x = variable1, y = variable2)` +3. **Géométries** : `geom_point()`, `geom_line()`, `geom_bar()` +4. **Personnalisation** : titres, couleurs, thèmes +::: + +::: {.fragment} +On **ajoute** des couches avec `+` +::: + +## Exercice 5 : Premier graphique ggplot2 {.smaller} + +**Demandez au LLM :** + +> "Comment créer un graphique simple avec ggplot2 en R ? Je débute avec ce package." + +**Ensuite, testez avec vos données de ventes :** + +```{r} +#| eval: false +library(ggplot2) + +ggplot(data = ventes, aes(x = mois, y = montant)) + + geom_col() +``` + +::: {.fragment} +**Questions :** + +1. Que fait `aes()` ? +2. Pourquoi `geom_col()` et pas `geom_bar()` ? +3. Comment changer la couleur des barres ? +::: + +::: {.notes} +20 minutes. Première découverte de ggplot2. La syntaxe peut surprendre au début. +::: + +## Exercice 6 : Améliorer le graphique {.smaller} + +**Personnalisez votre graphique :** + +```{r} +#| eval: false +ggplot(data = ventes, aes(x = mois, y = montant)) + + geom_col(fill = "steelblue") + + labs( + title = "Ventes mensuelles", + x = "Mois", + y = "Montant (€)" + ) + + theme_minimal() +``` + +::: {.fragment} +**Demandez au LLM :** + +> "Comment personnaliser les couleurs, titres et thème d'un graphique ggplot2 ?" +::: + +::: {.fragment} +**Explorez :** + +- Différentes couleurs +- Différents thèmes : `theme_bw()`, `theme_classic()` +- Ajout d'une ligne à un niveau spécifique avec `geom_hline()` +::: + +::: {.notes} +20 minutes. Exploration des options de personnalisation. +::: + +## Exercice 7 : Différents types de graphiques {.smaller} + +**Demandez au LLM de vous montrer comment créer :** + +1. Un graphique en **points** (`geom_point()`) +2. Un graphique en **lignes** (`geom_line()`) +3. Un **boxplot** (`geom_boxplot()`) +4. Un **histogramme** (`geom_histogram()`) + +::: {.fragment} +**Testez chaque type avec des données adaptées.** + +Certains types nécessitent des données spécifiques ! +::: + +::: {.notes} +20 minutes. Découverte de la variété des géométries disponibles. +::: + +## Exercice 8 : Graphiques par catégorie {.smaller} + +**Challenge :** Créez un graphique des ventes coloré par vendeur. + +**Demandez au LLM :** + +> "Comment créer un graphique avec ggplot2 où chaque catégorie a une couleur différente ?" + +::: {.fragment} +Vous découvrirez : + +```{r} +#| eval: false +ggplot(ventes, aes(x = mois, y = montant, fill = vendeur)) + + geom_col(position = "dodge") + + labs(title = "Ventes par vendeur et par mois") +``` +::: + +::: {.fragment} +**Questions :** + +1. Que fait `position = "dodge"` ? +2. Que se passe-t-il sans ? +3. Comment faire un graphique empilé ? +::: + +::: {.notes} +20 minutes. Introduction aux graphiques multivariés. +::: + +# Fonctions de visualisation {background-color="#8B008B"} + +## Pourquoi créer des fonctions graphiques ? + +Si vous créez souvent le même type de graphique : + +::: {.incremental} +- Éviter la **répétition** du code +- Garantir la **cohérence** visuelle +- Faciliter la **maintenance** +- Permettre la **réutilisation** +::: + +## Exercice 9 : Première fonction graphique {.smaller} + +**Créez une fonction qui génère un graphique en barres standard :** + +```{r} +#| eval: false +graphique_barres <- function(donnees, colonne_x, colonne_y, titre) { + ggplot(donnees, aes(x = .data[[colonne_x]], y = .data[[colonne_y]])) + + geom_col(fill = "steelblue") + + labs(title = titre) + + theme_minimal() +} + +# Utilisation +graphique_barres(ventes, "mois", "montant", "Ventes mensuelles") +``` + +::: {.fragment} +**Demandez au LLM d'expliquer :** + +1. À quoi sert `.data[[...]]` ? +2. Comment passer des noms de colonnes comme paramètres ? +::: + +::: {.notes} +20 minutes. Introduction aux fonctions avec ggplot2. Concept avancé mais important. +::: + +## Exercice 10 : Fonction graphique avancée {.smaller} + +**Améliorez votre fonction avec plus d'options :** + +```{r} +#| eval: false +graphique_personnalise <- function(donnees, x, y, titre, + couleur = "steelblue", + type = "barres") { + # Créer le graphique de base + g <- ggplot(donnees, aes(x = .data[[x]], y = .data[[y]])) + + # Ajouter la géométrie selon le type + if (type == "barres") { + g <- g + geom_col(fill = couleur) + } else if (type == "points") { + g <- g + geom_point(color = couleur, size = 3) + } + + # Ajouter titre et thème + g <- g + labs(title = titre) + theme_minimal() + + return(g) +} +``` + +::: {.fragment} +**Testez avec différentes options !** +::: + +::: {.notes} +20 minutes. Fonction plus sophistiquée avec options et conditions. +::: + +# Mini-projet : Dashboard {background-color="#DC143C"} + +## Projet : Analyse de ventes complète {.smaller} + +**Objectif :** Créer un dashboard d'analyse avec 4 graphiques différents. + +**Données :** + +```{r} +#| eval: false +# Téléchargez le fichier ventes_annuelles.csv depuis Moodle +ventes_annuelles <- read.csv("ventes_annuelles.csv") +``` + +**Les 4 graphiques à créer :** + +1. Évolution des ventes mensuelles (ligne) +2. Ventes par vendeur (barres) +3. Distribution des montants (histogramme) +4. Comparaison par trimestre (boxplot) + +::: {.callout-note} +## Utilisez ggplot2 pour tous les graphiques +Personnalisez-les avec des couleurs et titres appropriés. +::: + +::: {.notes} +40 minutes. Projet de synthèse. Combine nettoyage, analyse et visualisation. +::: + +## Critères du mini-projet {.smaller} + +::: {.incremental} +- ✅ Les données sont **nettoyées** (casse, NA gérés) +- ✅ Les 4 graphiques sont **créés avec ggplot2** +- ✅ Chaque graphique a un **titre et des labels** appropriés +- ✅ Le code est **commenté** +- ✅ Une **fonction de visualisation** réutilisable est créée +::: + +::: {.fragment} +**Bonus :** + +- Créer un 5ème graphique original +- Utiliser des facettes (`facet_wrap()`) +- Ajouter des annotations sur les graphiques +- Sauvegarder les graphiques avec `ggsave()` +::: + +# Retour réflexif {background-color="#2F4F4F"} + +## Exercice réflexif : Journal de bord {.smaller} + +**Documentez dans votre journal :** + +1. **Nettoyage de données** : + - Quels problèmes avez-vous rencontrés ? + - Comment les avez-vous résolus ? + - Un prompt efficace pour le nettoyage + +2. **ggplot2** : + - Différences avec `plot()` de base + - Votre graphique préféré créé aujourd'hui + - Un concept difficile à comprendre + +3. **Fonctions graphiques** : + - Pourquoi créer des fonctions pour les graphiques ? + - Code de votre fonction réutilisable + +::: {.notes} +10 minutes. Moment de réflexion et documentation. +::: + +## Ce que vous avez appris aujourd'hui + +::: {.incremental} +✅ Nettoyer des données réelles avec incohérences +✅ Utiliser ggplot2 pour créer des graphiques professionnels +✅ Maîtriser différentes géométries (barres, points, lignes, boxplot) +✅ Personnaliser l'apparence des graphiques +✅ Créer des fonctions de visualisation réutilisables +✅ Combiner analyse et communication visuelle +::: + +# Ressources et prochaines étapes {background-color="#2E8B57"} + +## Fonctions clés de cette séance + +**Nettoyage :** + +- `tolower()`, `toupper()` : standardiser la casse +- `na.omit()` : supprimer les NA +- `unique()`, `table()` : explorer les valeurs + +**ggplot2 :** + +- `ggplot()` + `aes()` : base du graphique +- `geom_col()`, `geom_point()`, `geom_line()` : géométries +- `labs()` : titres et labels +- `theme_minimal()`, `theme_bw()` : thèmes + +## Pour aller plus loin + +::: {.incremental} +- **Explorez** d'autres géométries de ggplot2 +- **Pratiquez** avec vos propres données +- **Créez** une bibliothèque de fonctions graphiques +- **Consultez** la documentation : `?ggplot2` +::: + +## Préparation prochaine séance + +::: {.callout-note} +## Devoirs + +1. Terminez le dashboard si besoin +2. **Mettez à jour votre journal** avec les détails de cette séance +3. Trouvez un jeu de données qui vous intéresse pour le projet de la séance 5 +4. Créez au moins 2 fonctions graphiques réutilisables +::: + +::: {.fragment} +**Prochaine séance :** Projet personnel intégré - vous allez mener une analyse complète en autonomie ! +::: + +## Questions ? + +::: {.callout-tip} +## Points clés à retenir + +- Le **nettoyage** des données est essentiel et prend du temps +- **ggplot2** permet de créer des graphiques professionnels de manière cohérente +- Les **fonctions graphiques** évitent la répétition et assurent la cohérence +- La **visualisation** est aussi importante que l'analyse +::: + +::: {.fragment} +**Bon courage et belles visualisations ! 📊** +::: \ No newline at end of file diff --git a/README.md b/README.md index f07525a..33d7a3f 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,12 @@ -# rl3 -Cous d'introduction à R, L3 économie-Finance +--- +lang: fr +--- + +# Initiation à la programmation (en R) à l'aide d'un LLM + +Présentations utilisées pour le cours d'initiation à la programmation (en R) à l'aide d'un LLM enseigné à l'université Paris 8 pendant l'année scolaire 2025-2026. + +Il y a deux principaux dossiers : + +- M3P, qui est organisé en 5 séances destinées à des étudiants en licence 3 économie-finance. +- ECLibre, qui est organisé en 8 séances destinées à des étudiants de licence en général, sans pré-requis particuliers. \ No newline at end of file diff --git a/_quarto.yml b/_quarto.yml new file mode 100644 index 0000000..f859fab --- /dev/null +++ b/_quarto.yml @@ -0,0 +1,49 @@ +project: + type: website + output-dir: _site + render: + - "*.qmd" + - "!JournalBord.qmd" + +author: + - name: Elias Bouacida + affiliation: "Université Paris 8" + orcid: 0000-0001-8656-6678 + email: elias.bouacida@univ-paris8.fr + +website: + title: "Initiation à R" + description: "Leçons pour le cours d'Initiation à R dispensé à l'université Paris 8 aux étudiants en licence 3 économie-finance." + sidebar: + style: "docked" + contents: + - text: "Index" + href: index.qmd + - section: "EC Libre : Introduction à la programmation (en R) avec des LLMs" + contents: ECLibre + - section: "Méthodologie de Projet Personnel et Professionnel" + contents: M3P + - section: "Annexe" + contents: + - text: "Modèle de journal de bord" + href: JournalBord.qmd + - text: "Données Météo" + href: donnees/donnees_meteo.csv + + +format: + html: + theme: default + toc: true + +bibliography: + - Bibliographie.bib + - BibliographieExercice.bib + +date: last-modified +date-format: long + +execute: + cache: true + +lang: fr \ No newline at end of file diff --git a/donnees/data.csv b/donnees/data.csv new file mode 100644 index 0000000..5f01e92 --- /dev/null +++ b/donnees/data.csv @@ -0,0 +1,16 @@ +x,y,valeur,categorie +1,10,125,A +2,15,230,B +3,8,98,A +4,22,310,C +5,18,189,B +6,12,145,A +7,25,350,C +8,20,267,B +9,14,178,A +10,28,405,C +11,16,198,B +12,11,132,A +13,30,420,C +14,19,245,B +15,13,156,A diff --git a/donnees/donnees_meteo.csv b/donnees/donnees_meteo.csv new file mode 100644 index 0000000..bcb0336 --- /dev/null +++ b/donnees/donnees_meteo.csv @@ -0,0 +1,11 @@ +date,temperature,precipitations,humidite,ville +2024-01-15,15.2,0,65,Paris +2024-01-16,18.5,5,72,Paris +2024-01-17,,2,68,Paris +2024-01-18,22.1,0,58,Paris +2024-01-19,16.8,8,75,Paris +2024-01-20,,1,70,Paris +2024-01-21,20.3,3,62,Paris +2024-01-22,14.7,0,64,Paris +2024-01-23,19.2,4,69,Paris +2024-01-24,17.6,0,61,Paris \ No newline at end of file diff --git a/donnees/ventes_fevrier.csv b/donnees/ventes_fevrier.csv new file mode 100644 index 0000000..2851efa --- /dev/null +++ b/donnees/ventes_fevrier.csv @@ -0,0 +1,11 @@ +date,produit,quantite,montant,region +2025-02-02,Ordinateur,4,4800,Nord +2025-02-05,Souris,18,270,Sud +2025-02-08,Clavier,10,400,Est +2025-02-10,Ecran,6,1500,Ouest +2025-02-12,Ordinateur,2,2400,Nord +2025-02-15,Souris,22,330,Sud +2025-02-18,Clavier,9,360,Est +2025-02-20,Ecran,8,2000,Ouest +2025-02-22,Ordinateur,5,6000,Nord +2025-02-25,Souris,12,180,Sud \ No newline at end of file diff --git a/donnees/ventes_janvier.csv b/donnees/ventes_janvier.csv new file mode 100644 index 0000000..3870069 --- /dev/null +++ b/donnees/ventes_janvier.csv @@ -0,0 +1,11 @@ +date,produit,quantite,montant,region +2025-01-05,Ordinateur,2,2400,Nord +2025-01-08,Souris,15,225,Sud +2025-01-10,Clavier,8,320,Est +2025-01-12,Ecran,5,1250,Ouest +2025-01-15,Ordinateur,3,3600,Nord +2025-01-18,Souris,20,300,Sud +2025-01-20,Clavier,12,480,Est +2025-01-22,Ecran,7,1750,Ouest +2025-01-25,Ordinateur,1,1200,Nord +2025-01-28,Souris,10,150,Sud \ No newline at end of file diff --git a/donnees/ventes_mars.csv b/donnees/ventes_mars.csv new file mode 100644 index 0000000..2e93607 --- /dev/null +++ b/donnees/ventes_mars.csv @@ -0,0 +1,11 @@ +date,produit,quantite,montant,region +2025-03-03,Ordinateur,3,3600,Nord +2025-03-06,Souris,25,375,Sud +2025-03-09,Clavier,14,560,Est +2025-03-12,Ecran,4,1000,Ouest +2025-03-15,Ordinateur,6,7200,Nord +2025-03-18,Souris,16,240,Sud +2025-03-21,Clavier,11,440,Est +2025-03-24,Ecran,9,2250,Ouest +2025-03-27,Ordinateur,2,2400,Nord +2025-03-30,Souris,19,285,Sud \ No newline at end of file diff --git a/get_data.R b/get_data.R deleted file mode 100644 index 7e82ff4..0000000 --- a/get_data.R +++ /dev/null @@ -1,4 +0,0 @@ -library(questionr) -library(readr) -data(hdv2003) -write_csv(hdv2003, file="./bases/hdv3.csv") diff --git a/index.qmd b/index.qmd new file mode 100644 index 0000000..1ccfe96 --- /dev/null +++ b/index.qmd @@ -0,0 +1,47 @@ +--- +title: Initiation à la programmation (en R) à l'aide des LLMs +subtitle: Plan général +author: Elias Bouacida +format: html +lang: fr +date: last-modified +date-format: long +--- + +Ce site contient la plupart des présentations utilisées pour le cours d'introduction à la programmation (en R) dispensé au sein de l'université Paris 8. + + +# Syllabus + +Une ressource bibliographique utile pour comprendre de nombreux concepts en R est proposée par @Barnier. + +## Plan du cours + +Le cours est structuré en 3 phases progressives sur 8 séances de 3h. + +### Phase 1 : Fondations 🌱 (Séances 1-3) + +**Objectif :** Maîtriser le dialogue avec un LLM et les concepts R de base + +### Phase 2 : Application 🚀 (Séances 4-5) + +**Objectif :** Analyser de vraies données en autonomie + +### Phase 3 : Expertise ⭐ (Séances 6-8) + +**Objectif :** Devenir autonome et collaborer efficacement + + +**À la fin du cours, vous serez capable de :** analyser des données en autonomie, créer vos propres outils, automatiser vos analyses, collaborer sur du code, et utiliser les LLMs comme de véritables partenaires de travail. + +## Validation + + +En M3P, c'est un cours à validation. +En EC libre, c'est un cours noté, l'évaluation varie donc un peu entre les deux. + +# Organisation du site + +Pour chaque module, vous trouverez la présentation sous la forme d'une page web classique (`html`) et une version sous la forme d'une présentation téléchargeable en cliquant à droite sur `revealjs`. + +# Références diff --git a/renv.lock b/renv.lock new file mode 100644 index 0000000..ed4da40 --- /dev/null +++ b/renv.lock @@ -0,0 +1,1720 @@ +{ + "R": { + "Version": "4.5.1", + "Repositories": [ + { + "Name": "CRAN", + "URL": "https://packagemanager.posit.co/cran/latest" + } + ] + }, + "Packages": { + "R6": { + "Package": "R6", + "Version": "2.6.1", + "Source": "Repository", + "Title": "Encapsulated Classes with Reference Semantics", + "Authors@R": "c( person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = c(\"aut\", \"cre\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Creates classes with reference semantics, similar to R's built-in reference classes. Compared to reference classes, R6 classes are simpler and lighter-weight, and they are not built on S4 classes so they do not require the methods package. These classes allow public and private members, and they support inheritance, even when the classes are defined in different packages.", + "License": "MIT + file LICENSE", + "URL": "https://r6.r-lib.org, https://github.com/r-lib/R6", + "BugReports": "https://github.com/r-lib/R6/issues", + "Depends": [ + "R (>= 3.6)" + ], + "Suggests": [ + "lobstr", + "testthat (>= 3.0.0)" + ], + "Config/Needs/website": "tidyverse/tidytemplate, ggplot2, microbenchmark, scales", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Winston Chang [aut, cre], Posit Software, PBC [cph, fnd]", + "Maintainer": "Winston Chang ", + "Repository": "CRAN" + }, + "RColorBrewer": { + "Package": "RColorBrewer", + "Version": "1.1-3", + "Source": "Repository", + "Date": "2022-04-03", + "Title": "ColorBrewer Palettes", + "Authors@R": "c(person(given = \"Erich\", family = \"Neuwirth\", role = c(\"aut\", \"cre\"), email = \"erich.neuwirth@univie.ac.at\"))", + "Author": "Erich Neuwirth [aut, cre]", + "Maintainer": "Erich Neuwirth ", + "Depends": [ + "R (>= 2.0.0)" + ], + "Description": "Provides color schemes for maps (and other graphics) designed by Cynthia Brewer as described at http://colorbrewer2.org.", + "License": "Apache License 2.0", + "NeedsCompilation": "no", + "Repository": "CRAN" + }, + "Rcpp": { + "Package": "Rcpp", + "Version": "1.1.0", + "Source": "Repository", + "Title": "Seamless R and C++ Integration", + "Date": "2025-07-01", + "Authors@R": "c(person(\"Dirk\", \"Eddelbuettel\", role = c(\"aut\", \"cre\"), email = \"edd@debian.org\", comment = c(ORCID = \"0000-0001-6419-907X\")), person(\"Romain\", \"Francois\", role = \"aut\", comment = c(ORCID = \"0000-0002-2444-4226\")), person(\"JJ\", \"Allaire\", role = \"aut\", comment = c(ORCID = \"0000-0003-0174-9868\")), person(\"Kevin\", \"Ushey\", role = \"aut\", comment = c(ORCID = \"0000-0003-2880-7407\")), person(\"Qiang\", \"Kou\", role = \"aut\", comment = c(ORCID = \"0000-0001-6786-5453\")), person(\"Nathan\", \"Russell\", role = \"aut\"), person(\"Iñaki\", \"Ucar\", role = \"aut\", comment = c(ORCID = \"0000-0001-6403-5550\")), person(\"Doug\", \"Bates\", role = \"aut\", comment = c(ORCID = \"0000-0001-8316-9503\")), person(\"John\", \"Chambers\", role = \"aut\"))", + "Description": "The 'Rcpp' package provides R functions as well as C++ classes which offer a seamless integration of R and C++. Many R data types and objects can be mapped back and forth to C++ equivalents which facilitates both writing of new code as well as easier integration of third-party libraries. Documentation about 'Rcpp' is provided by several vignettes included in this package, via the 'Rcpp Gallery' site at , the paper by Eddelbuettel and Francois (2011, ), the book by Eddelbuettel (2013, ) and the paper by Eddelbuettel and Balamuta (2018, ); see 'citation(\"Rcpp\")' for details.", + "Imports": [ + "methods", + "utils" + ], + "Suggests": [ + "tinytest", + "inline", + "rbenchmark", + "pkgKitten (>= 0.1.2)" + ], + "URL": "https://www.rcpp.org, https://dirk.eddelbuettel.com/code/rcpp.html, https://github.com/RcppCore/Rcpp", + "License": "GPL (>= 2)", + "BugReports": "https://github.com/RcppCore/Rcpp/issues", + "MailingList": "rcpp-devel@lists.r-forge.r-project.org", + "RoxygenNote": "6.1.1", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Author": "Dirk Eddelbuettel [aut, cre] (ORCID: ), Romain Francois [aut] (ORCID: ), JJ Allaire [aut] (ORCID: ), Kevin Ushey [aut] (ORCID: ), Qiang Kou [aut] (ORCID: ), Nathan Russell [aut], Iñaki Ucar [aut] (ORCID: ), Doug Bates [aut] (ORCID: ), John Chambers [aut]", + "Maintainer": "Dirk Eddelbuettel ", + "Repository": "CRAN" + }, + "S7": { + "Package": "S7", + "Version": "0.2.0", + "Source": "Repository", + "Title": "An Object Oriented System Meant to Become a Successor to S3 and S4", + "Authors@R": "c( person(\"Object-Oriented Programming Working Group\", role = \"cph\"), person(\"Davis\", \"Vaughan\", role = \"aut\"), person(\"Jim\", \"Hester\", role = \"aut\", comment = c(ORCID = \"0000-0002-2739-7082\")), person(\"Tomasz\", \"Kalinowski\", role = \"aut\"), person(\"Will\", \"Landau\", role = \"aut\"), person(\"Michael\", \"Lawrence\", role = \"aut\"), person(\"Martin\", \"Maechler\", role = \"aut\", comment = c(ORCID = \"0000-0002-8685-9910\")), person(\"Luke\", \"Tierney\", role = \"aut\"), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0003-4757-117X\")) )", + "Description": "A new object oriented programming system designed to be a successor to S3 and S4. It includes formal class, generic, and method specification, and a limited form of multiple dispatch. It has been designed and implemented collaboratively by the R Consortium Object-Oriented Programming Working Group, which includes representatives from R-Core, 'Bioconductor', 'Posit'/'tidyverse', and the wider R community.", + "License": "MIT + file LICENSE", + "URL": "https://rconsortium.github.io/S7/, https://github.com/RConsortium/S7", + "BugReports": "https://github.com/RConsortium/S7/issues", + "Depends": [ + "R (>= 3.5.0)" + ], + "Imports": [ + "utils" + ], + "Suggests": [ + "bench", + "callr", + "covr", + "knitr", + "methods", + "rmarkdown", + "testthat (>= 3.2.0)", + "tibble" + ], + "VignetteBuilder": "knitr", + "Config/build/compilation-database": "true", + "Config/Needs/website": "sloop", + "Config/testthat/edition": "3", + "Config/testthat/parallel": "TRUE", + "Config/testthat/start-first": "external-generic", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "yes", + "Author": "Object-Oriented Programming Working Group [cph], Davis Vaughan [aut], Jim Hester [aut] (), Tomasz Kalinowski [aut], Will Landau [aut], Michael Lawrence [aut], Martin Maechler [aut] (), Luke Tierney [aut], Hadley Wickham [aut, cre] ()", + "Maintainer": "Hadley Wickham ", + "Repository": "CRAN" + }, + "base64enc": { + "Package": "base64enc", + "Version": "0.1-3", + "Source": "Repository", + "Title": "Tools for base64 encoding", + "Author": "Simon Urbanek ", + "Maintainer": "Simon Urbanek ", + "Depends": [ + "R (>= 2.9.0)" + ], + "Enhances": [ + "png" + ], + "Description": "This package provides tools for handling base64 encoding. It is more flexible than the orphaned base64 package.", + "License": "GPL-2 | GPL-3", + "URL": "http://www.rforge.net/base64enc", + "NeedsCompilation": "yes", + "Repository": "CRAN" + }, + "bslib": { + "Package": "bslib", + "Version": "0.9.0", + "Source": "Repository", + "Title": "Custom 'Bootstrap' 'Sass' Themes for 'shiny' and 'rmarkdown'", + "Authors@R": "c( person(\"Carson\", \"Sievert\", , \"carson@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = \"aut\"), person(\"Garrick\", \"Aden-Buie\", , \"garrick@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0002-7111-0077\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")), person(, \"Bootstrap contributors\", role = \"ctb\", comment = \"Bootstrap library\"), person(, \"Twitter, Inc\", role = \"cph\", comment = \"Bootstrap library\"), person(\"Javi\", \"Aguilar\", role = c(\"ctb\", \"cph\"), comment = \"Bootstrap colorpicker library\"), person(\"Thomas\", \"Park\", role = c(\"ctb\", \"cph\"), comment = \"Bootswatch library\"), person(, \"PayPal\", role = c(\"ctb\", \"cph\"), comment = \"Bootstrap accessibility plugin\") )", + "Description": "Simplifies custom 'CSS' styling of both 'shiny' and 'rmarkdown' via 'Bootstrap' 'Sass'. Supports 'Bootstrap' 3, 4 and 5 as well as their various 'Bootswatch' themes. An interactive widget is also provided for previewing themes in real time.", + "License": "MIT + file LICENSE", + "URL": "https://rstudio.github.io/bslib/, https://github.com/rstudio/bslib", + "BugReports": "https://github.com/rstudio/bslib/issues", + "Depends": [ + "R (>= 2.10)" + ], + "Imports": [ + "base64enc", + "cachem", + "fastmap (>= 1.1.1)", + "grDevices", + "htmltools (>= 0.5.8)", + "jquerylib (>= 0.1.3)", + "jsonlite", + "lifecycle", + "memoise (>= 2.0.1)", + "mime", + "rlang", + "sass (>= 0.4.9)" + ], + "Suggests": [ + "bsicons", + "curl", + "fontawesome", + "future", + "ggplot2", + "knitr", + "magrittr", + "rappdirs", + "rmarkdown (>= 2.7)", + "shiny (> 1.8.1)", + "testthat", + "thematic", + "tools", + "utils", + "withr", + "yaml" + ], + "Config/Needs/deploy": "BH, chiflights22, colourpicker, commonmark, cpp11, cpsievert/chiflights22, cpsievert/histoslider, dplyr, DT, ggplot2, ggridges, gt, hexbin, histoslider, htmlwidgets, lattice, leaflet, lubridate, markdown, modelr, plotly, reactable, reshape2, rprojroot, rsconnect, rstudio/shiny, scales, styler, tibble", + "Config/Needs/routine": "chromote, desc, renv", + "Config/Needs/website": "brio, crosstalk, dplyr, DT, ggplot2, glue, htmlwidgets, leaflet, lorem, palmerpenguins, plotly, purrr, rprojroot, rstudio/htmltools, scales, stringr, tidyr, webshot2", + "Config/testthat/edition": "3", + "Config/testthat/parallel": "true", + "Config/testthat/start-first": "zzzz-bs-sass, fonts, zzz-precompile, theme-*, rmd-*", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "Collate": "'accordion.R' 'breakpoints.R' 'bs-current-theme.R' 'bs-dependencies.R' 'bs-global.R' 'bs-remove.R' 'bs-theme-layers.R' 'bs-theme-preset-bootswatch.R' 'bs-theme-preset-brand.R' 'bs-theme-preset-builtin.R' 'bs-theme-preset.R' 'utils.R' 'bs-theme-preview.R' 'bs-theme-update.R' 'bs-theme.R' 'bslib-package.R' 'buttons.R' 'card.R' 'deprecated.R' 'files.R' 'fill.R' 'imports.R' 'input-dark-mode.R' 'input-switch.R' 'layout.R' 'nav-items.R' 'nav-update.R' 'navbar_options.R' 'navs-legacy.R' 'navs.R' 'onLoad.R' 'page.R' 'popover.R' 'precompiled.R' 'print.R' 'shiny-devmode.R' 'sidebar.R' 'staticimports.R' 'tooltip.R' 'utils-deps.R' 'utils-shiny.R' 'utils-tags.R' 'value-box.R' 'version-default.R' 'versions.R'", + "NeedsCompilation": "no", + "Author": "Carson Sievert [aut, cre] (), Joe Cheng [aut], Garrick Aden-Buie [aut] (), Posit Software, PBC [cph, fnd], Bootstrap contributors [ctb] (Bootstrap library), Twitter, Inc [cph] (Bootstrap library), Javi Aguilar [ctb, cph] (Bootstrap colorpicker library), Thomas Park [ctb, cph] (Bootswatch library), PayPal [ctb, cph] (Bootstrap accessibility plugin)", + "Maintainer": "Carson Sievert ", + "Repository": "CRAN" + }, + "cachem": { + "Package": "cachem", + "Version": "1.1.0", + "Source": "Repository", + "Title": "Cache R Objects with Automatic Pruning", + "Description": "Key-value stores with automatic pruning. Caches can limit either their total size or the age of the oldest object (or both), automatically pruning objects to maintain the constraints.", + "Authors@R": "c( person(\"Winston\", \"Chang\", , \"winston@posit.co\", c(\"aut\", \"cre\")), person(family = \"Posit Software, PBC\", role = c(\"cph\", \"fnd\")))", + "License": "MIT + file LICENSE", + "Encoding": "UTF-8", + "ByteCompile": "true", + "URL": "https://cachem.r-lib.org/, https://github.com/r-lib/cachem", + "Imports": [ + "rlang", + "fastmap (>= 1.2.0)" + ], + "Suggests": [ + "testthat" + ], + "RoxygenNote": "7.2.3", + "Config/Needs/routine": "lobstr", + "Config/Needs/website": "pkgdown", + "NeedsCompilation": "yes", + "Author": "Winston Chang [aut, cre], Posit Software, PBC [cph, fnd]", + "Maintainer": "Winston Chang ", + "Repository": "CRAN" + }, + "cli": { + "Package": "cli", + "Version": "3.6.5", + "Source": "Repository", + "Title": "Helpers for Developing Command Line Interfaces", + "Authors@R": "c( person(\"Gábor\", \"Csárdi\", , \"gabor@posit.co\", role = c(\"aut\", \"cre\")), person(\"Hadley\", \"Wickham\", role = \"ctb\"), person(\"Kirill\", \"Müller\", role = \"ctb\"), person(\"Salim\", \"Brüggemann\", , \"salim-b@pm.me\", role = \"ctb\", comment = c(ORCID = \"0000-0002-5329-5987\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "A suite of tools to build attractive command line interfaces ('CLIs'), from semantic elements: headings, lists, alerts, paragraphs, etc. Supports custom themes via a 'CSS'-like language. It also contains a number of lower level 'CLI' elements: rules, boxes, trees, and 'Unicode' symbols with 'ASCII' alternatives. It support ANSI colors and text styles as well.", + "License": "MIT + file LICENSE", + "URL": "https://cli.r-lib.org, https://github.com/r-lib/cli", + "BugReports": "https://github.com/r-lib/cli/issues", + "Depends": [ + "R (>= 3.4)" + ], + "Imports": [ + "utils" + ], + "Suggests": [ + "callr", + "covr", + "crayon", + "digest", + "glue (>= 1.6.0)", + "grDevices", + "htmltools", + "htmlwidgets", + "knitr", + "methods", + "processx", + "ps (>= 1.3.4.9000)", + "rlang (>= 1.0.2.9003)", + "rmarkdown", + "rprojroot", + "rstudioapi", + "testthat (>= 3.2.0)", + "tibble", + "whoami", + "withr" + ], + "Config/Needs/website": "r-lib/asciicast, bench, brio, cpp11, decor, desc, fansi, prettyunits, sessioninfo, tidyverse/tidytemplate, usethis, vctrs", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "yes", + "Author": "Gábor Csárdi [aut, cre], Hadley Wickham [ctb], Kirill Müller [ctb], Salim Brüggemann [ctb] (), Posit Software, PBC [cph, fnd]", + "Maintainer": "Gábor Csárdi ", + "Repository": "RSPM" + }, + "commonmark": { + "Package": "commonmark", + "Version": "2.0.0", + "Source": "Repository", + "Type": "Package", + "Title": "High Performance CommonMark and Github Markdown Rendering in R", + "Authors@R": "c( person(\"Jeroen\", \"Ooms\", ,\"jeroenooms@gmail.com\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-4035-0289\")), person(\"John MacFarlane\", role = \"cph\", comment = \"Author of cmark\"))", + "Description": "The CommonMark specification defines a rationalized version of markdown syntax. This package uses the 'cmark' reference implementation for converting markdown text into various formats including html, latex and groff man. In addition it exposes the markdown parse tree in xml format. Also includes opt-in support for GFM extensions including tables, autolinks, and strikethrough text.", + "License": "BSD_2_clause + file LICENSE", + "URL": "https://docs.ropensci.org/commonmark/ https://ropensci.r-universe.dev/commonmark", + "BugReports": "https://github.com/r-lib/commonmark/issues", + "Suggests": [ + "curl", + "testthat", + "xml2" + ], + "RoxygenNote": "7.3.2", + "Language": "en-US", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Author": "Jeroen Ooms [aut, cre] (ORCID: ), John MacFarlane [cph] (Author of cmark)", + "Maintainer": "Jeroen Ooms ", + "Repository": "RSPM" + }, + "digest": { + "Package": "digest", + "Version": "0.6.37", + "Source": "Repository", + "Authors@R": "c(person(\"Dirk\", \"Eddelbuettel\", role = c(\"aut\", \"cre\"), email = \"edd@debian.org\", comment = c(ORCID = \"0000-0001-6419-907X\")), person(\"Antoine\", \"Lucas\", role=\"ctb\"), person(\"Jarek\", \"Tuszynski\", role=\"ctb\"), person(\"Henrik\", \"Bengtsson\", role=\"ctb\", comment = c(ORCID = \"0000-0002-7579-5165\")), person(\"Simon\", \"Urbanek\", role=\"ctb\", comment = c(ORCID = \"0000-0003-2297-1732\")), person(\"Mario\", \"Frasca\", role=\"ctb\"), person(\"Bryan\", \"Lewis\", role=\"ctb\"), person(\"Murray\", \"Stokely\", role=\"ctb\"), person(\"Hannes\", \"Muehleisen\", role=\"ctb\"), person(\"Duncan\", \"Murdoch\", role=\"ctb\"), person(\"Jim\", \"Hester\", role=\"ctb\"), person(\"Wush\", \"Wu\", role=\"ctb\", comment = c(ORCID = \"0000-0001-5180-0567\")), person(\"Qiang\", \"Kou\", role=\"ctb\", comment = c(ORCID = \"0000-0001-6786-5453\")), person(\"Thierry\", \"Onkelinx\", role=\"ctb\", comment = c(ORCID = \"0000-0001-8804-4216\")), person(\"Michel\", \"Lang\", role=\"ctb\", comment = c(ORCID = \"0000-0001-9754-0393\")), person(\"Viliam\", \"Simko\", role=\"ctb\"), person(\"Kurt\", \"Hornik\", role=\"ctb\", comment = c(ORCID = \"0000-0003-4198-9911\")), person(\"Radford\", \"Neal\", role=\"ctb\", comment = c(ORCID = \"0000-0002-2473-3407\")), person(\"Kendon\", \"Bell\", role=\"ctb\", comment = c(ORCID = \"0000-0002-9093-8312\")), person(\"Matthew\", \"de Queljoe\", role=\"ctb\"), person(\"Dmitry\", \"Selivanov\", role=\"ctb\"), person(\"Ion\", \"Suruceanu\", role=\"ctb\"), person(\"Bill\", \"Denney\", role=\"ctb\"), person(\"Dirk\", \"Schumacher\", role=\"ctb\"), person(\"András\", \"Svraka\", role=\"ctb\"), person(\"Sergey\", \"Fedorov\", role=\"ctb\"), person(\"Will\", \"Landau\", role=\"ctb\", comment = c(ORCID = \"0000-0003-1878-3253\")), person(\"Floris\", \"Vanderhaeghe\", role=\"ctb\", comment = c(ORCID = \"0000-0002-6378-6229\")), person(\"Kevin\", \"Tappe\", role=\"ctb\"), person(\"Harris\", \"McGehee\", role=\"ctb\"), person(\"Tim\", \"Mastny\", role=\"ctb\"), person(\"Aaron\", \"Peikert\", role=\"ctb\", comment = c(ORCID = \"0000-0001-7813-818X\")), person(\"Mark\", \"van der Loo\", role=\"ctb\", comment = c(ORCID = \"0000-0002-9807-4686\")), person(\"Chris\", \"Muir\", role=\"ctb\", comment = c(ORCID = \"0000-0003-2555-3878\")), person(\"Moritz\", \"Beller\", role=\"ctb\", comment = c(ORCID = \"0000-0003-4852-0526\")), person(\"Sebastian\", \"Campbell\", role=\"ctb\"), person(\"Winston\", \"Chang\", role=\"ctb\", comment = c(ORCID = \"0000-0002-1576-2126\")), person(\"Dean\", \"Attali\", role=\"ctb\", comment = c(ORCID = \"0000-0002-5645-3493\")), person(\"Michael\", \"Chirico\", role=\"ctb\", comment = c(ORCID = \"0000-0003-0787-087X\")), person(\"Kevin\", \"Ushey\", role=\"ctb\"))", + "Date": "2024-08-19", + "Title": "Create Compact Hash Digests of R Objects", + "Description": "Implementation of a function 'digest()' for the creation of hash digests of arbitrary R objects (using the 'md5', 'sha-1', 'sha-256', 'crc32', 'xxhash', 'murmurhash', 'spookyhash', 'blake3', 'crc32c', 'xxh3_64', and 'xxh3_128' algorithms) permitting easy comparison of R language objects, as well as functions such as'hmac()' to create hash-based message authentication code. Please note that this package is not meant to be deployed for cryptographic purposes for which more comprehensive (and widely tested) libraries such as 'OpenSSL' should be used.", + "URL": "https://github.com/eddelbuettel/digest, https://dirk.eddelbuettel.com/code/digest.html", + "BugReports": "https://github.com/eddelbuettel/digest/issues", + "Depends": [ + "R (>= 3.3.0)" + ], + "Imports": [ + "utils" + ], + "License": "GPL (>= 2)", + "Suggests": [ + "tinytest", + "simplermarkdown" + ], + "VignetteBuilder": "simplermarkdown", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Author": "Dirk Eddelbuettel [aut, cre] (), Antoine Lucas [ctb], Jarek Tuszynski [ctb], Henrik Bengtsson [ctb] (), Simon Urbanek [ctb] (), Mario Frasca [ctb], Bryan Lewis [ctb], Murray Stokely [ctb], Hannes Muehleisen [ctb], Duncan Murdoch [ctb], Jim Hester [ctb], Wush Wu [ctb] (), Qiang Kou [ctb] (), Thierry Onkelinx [ctb] (), Michel Lang [ctb] (), Viliam Simko [ctb], Kurt Hornik [ctb] (), Radford Neal [ctb] (), Kendon Bell [ctb] (), Matthew de Queljoe [ctb], Dmitry Selivanov [ctb], Ion Suruceanu [ctb], Bill Denney [ctb], Dirk Schumacher [ctb], András Svraka [ctb], Sergey Fedorov [ctb], Will Landau [ctb] (), Floris Vanderhaeghe [ctb] (), Kevin Tappe [ctb], Harris McGehee [ctb], Tim Mastny [ctb], Aaron Peikert [ctb] (), Mark van der Loo [ctb] (), Chris Muir [ctb] (), Moritz Beller [ctb] (), Sebastian Campbell [ctb], Winston Chang [ctb] (), Dean Attali [ctb] (), Michael Chirico [ctb] (), Kevin Ushey [ctb]", + "Maintainer": "Dirk Eddelbuettel ", + "Repository": "CRAN" + }, + "evaluate": { + "Package": "evaluate", + "Version": "1.0.5", + "Source": "Repository", + "Type": "Package", + "Title": "Parsing and Evaluation Tools that Provide More Details than the Default", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = c(\"aut\", \"cre\")), person(\"Yihui\", \"Xie\", role = \"aut\", comment = c(ORCID = \"0000-0003-0645-5666\")), person(\"Michael\", \"Lawrence\", role = \"ctb\"), person(\"Thomas\", \"Kluyver\", role = \"ctb\"), person(\"Jeroen\", \"Ooms\", role = \"ctb\"), person(\"Barret\", \"Schloerke\", role = \"ctb\"), person(\"Adam\", \"Ryczkowski\", role = \"ctb\"), person(\"Hiroaki\", \"Yutani\", role = \"ctb\"), person(\"Michel\", \"Lang\", role = \"ctb\"), person(\"Karolis\", \"Koncevičius\", role = \"ctb\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Parsing and evaluation tools that make it easy to recreate the command line behaviour of R.", + "License": "MIT + file LICENSE", + "URL": "https://evaluate.r-lib.org/, https://github.com/r-lib/evaluate", + "BugReports": "https://github.com/r-lib/evaluate/issues", + "Depends": [ + "R (>= 3.6.0)" + ], + "Suggests": [ + "callr", + "covr", + "ggplot2 (>= 3.3.6)", + "lattice", + "methods", + "pkgload", + "ragg (>= 1.4.0)", + "rlang (>= 1.1.5)", + "knitr", + "testthat (>= 3.0.0)", + "withr" + ], + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Hadley Wickham [aut, cre], Yihui Xie [aut] (ORCID: ), Michael Lawrence [ctb], Thomas Kluyver [ctb], Jeroen Ooms [ctb], Barret Schloerke [ctb], Adam Ryczkowski [ctb], Hiroaki Yutani [ctb], Michel Lang [ctb], Karolis Koncevičius [ctb], Posit Software, PBC [cph, fnd]", + "Maintainer": "Hadley Wickham ", + "Repository": "CRAN" + }, + "farver": { + "Package": "farver", + "Version": "2.1.2", + "Source": "Repository", + "Type": "Package", + "Title": "High Performance Colour Space Manipulation", + "Authors@R": "c( person(\"Thomas Lin\", \"Pedersen\", , \"thomas.pedersen@posit.co\", role = c(\"cre\", \"aut\"), comment = c(ORCID = \"0000-0002-5147-4711\")), person(\"Berendea\", \"Nicolae\", role = \"aut\", comment = \"Author of the ColorSpace C++ library\"), person(\"Romain\", \"François\", , \"romain@purrple.cat\", role = \"aut\", comment = c(ORCID = \"0000-0002-2444-4226\")), person(\"Posit, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "The encoding of colour can be handled in many different ways, using different colour spaces. As different colour spaces have different uses, efficient conversion between these representations are important. The 'farver' package provides a set of functions that gives access to very fast colour space conversion and comparisons implemented in C++, and offers speed improvements over the 'convertColor' function in the 'grDevices' package.", + "License": "MIT + file LICENSE", + "URL": "https://farver.data-imaginist.com, https://github.com/thomasp85/farver", + "BugReports": "https://github.com/thomasp85/farver/issues", + "Suggests": [ + "covr", + "testthat (>= 3.0.0)" + ], + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.1", + "NeedsCompilation": "yes", + "Author": "Thomas Lin Pedersen [cre, aut] (), Berendea Nicolae [aut] (Author of the ColorSpace C++ library), Romain François [aut] (), Posit, PBC [cph, fnd]", + "Maintainer": "Thomas Lin Pedersen ", + "Repository": "CRAN" + }, + "fastmap": { + "Package": "fastmap", + "Version": "1.2.0", + "Source": "Repository", + "Title": "Fast Data Structures", + "Authors@R": "c( person(\"Winston\", \"Chang\", email = \"winston@posit.co\", role = c(\"aut\", \"cre\")), person(given = \"Posit Software, PBC\", role = c(\"cph\", \"fnd\")), person(given = \"Tessil\", role = \"cph\", comment = \"hopscotch_map library\") )", + "Description": "Fast implementation of data structures, including a key-value store, stack, and queue. Environments are commonly used as key-value stores in R, but every time a new key is used, it is added to R's global symbol table, causing a small amount of memory leakage. This can be problematic in cases where many different keys are used. Fastmap avoids this memory leak issue by implementing the map using data structures in C++.", + "License": "MIT + file LICENSE", + "Encoding": "UTF-8", + "RoxygenNote": "7.2.3", + "Suggests": [ + "testthat (>= 2.1.1)" + ], + "URL": "https://r-lib.github.io/fastmap/, https://github.com/r-lib/fastmap", + "BugReports": "https://github.com/r-lib/fastmap/issues", + "NeedsCompilation": "yes", + "Author": "Winston Chang [aut, cre], Posit Software, PBC [cph, fnd], Tessil [cph] (hopscotch_map library)", + "Maintainer": "Winston Chang ", + "Repository": "CRAN" + }, + "fontawesome": { + "Package": "fontawesome", + "Version": "0.5.3", + "Source": "Repository", + "Type": "Package", + "Title": "Easily Work with 'Font Awesome' Icons", + "Description": "Easily and flexibly insert 'Font Awesome' icons into 'R Markdown' documents and 'Shiny' apps. These icons can be inserted into HTML content through inline 'SVG' tags or 'i' tags. There is also a utility function for exporting 'Font Awesome' icons as 'PNG' images for those situations where raster graphics are needed.", + "Authors@R": "c( person(\"Richard\", \"Iannone\", , \"rich@posit.co\", c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0003-3925-190X\")), person(\"Christophe\", \"Dervieux\", , \"cderv@posit.co\", role = \"ctb\", comment = c(ORCID = \"0000-0003-4474-2498\")), person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = \"ctb\"), person(\"Dave\", \"Gandy\", role = c(\"ctb\", \"cph\"), comment = \"Font-Awesome font\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "License": "MIT + file LICENSE", + "URL": "https://github.com/rstudio/fontawesome, https://rstudio.github.io/fontawesome/", + "BugReports": "https://github.com/rstudio/fontawesome/issues", + "Encoding": "UTF-8", + "ByteCompile": "true", + "RoxygenNote": "7.3.2", + "Depends": [ + "R (>= 3.3.0)" + ], + "Imports": [ + "rlang (>= 1.0.6)", + "htmltools (>= 0.5.1.1)" + ], + "Suggests": [ + "covr", + "dplyr (>= 1.0.8)", + "gt (>= 0.9.0)", + "knitr (>= 1.31)", + "testthat (>= 3.0.0)", + "rsvg" + ], + "Config/testthat/edition": "3", + "NeedsCompilation": "no", + "Author": "Richard Iannone [aut, cre] (), Christophe Dervieux [ctb] (), Winston Chang [ctb], Dave Gandy [ctb, cph] (Font-Awesome font), Posit Software, PBC [cph, fnd]", + "Maintainer": "Richard Iannone ", + "Repository": "CRAN" + }, + "fs": { + "Package": "fs", + "Version": "1.6.6", + "Source": "Repository", + "Title": "Cross-Platform File System Operations Based on 'libuv'", + "Authors@R": "c( person(\"Jim\", \"Hester\", role = \"aut\"), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Gábor\", \"Csárdi\", , \"csardi.gabor@gmail.com\", role = c(\"aut\", \"cre\")), person(\"libuv project contributors\", role = \"cph\", comment = \"libuv library\"), person(\"Joyent, Inc. and other Node contributors\", role = \"cph\", comment = \"libuv library\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "A cross-platform interface to file system operations, built on top of the 'libuv' C library.", + "License": "MIT + file LICENSE", + "URL": "https://fs.r-lib.org, https://github.com/r-lib/fs", + "BugReports": "https://github.com/r-lib/fs/issues", + "Depends": [ + "R (>= 3.6)" + ], + "Imports": [ + "methods" + ], + "Suggests": [ + "covr", + "crayon", + "knitr", + "pillar (>= 1.0.0)", + "rmarkdown", + "spelling", + "testthat (>= 3.0.0)", + "tibble (>= 1.1.0)", + "vctrs (>= 0.3.0)", + "withr" + ], + "VignetteBuilder": "knitr", + "ByteCompile": "true", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Copyright": "file COPYRIGHTS", + "Encoding": "UTF-8", + "Language": "en-US", + "RoxygenNote": "7.2.3", + "SystemRequirements": "GNU make", + "NeedsCompilation": "yes", + "Author": "Jim Hester [aut], Hadley Wickham [aut], Gábor Csárdi [aut, cre], libuv project contributors [cph] (libuv library), Joyent, Inc. and other Node contributors [cph] (libuv library), Posit Software, PBC [cph, fnd]", + "Maintainer": "Gábor Csárdi ", + "Repository": "CRAN" + }, + "ggplot2": { + "Package": "ggplot2", + "Version": "4.0.0", + "Source": "Repository", + "Title": "Create Elegant Data Visualisations Using the Grammar of Graphics", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0003-4757-117X\")), person(\"Winston\", \"Chang\", role = \"aut\", comment = c(ORCID = \"0000-0002-1576-2126\")), person(\"Lionel\", \"Henry\", role = \"aut\"), person(\"Thomas Lin\", \"Pedersen\", , \"thomas.pedersen@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-5147-4711\")), person(\"Kohske\", \"Takahashi\", role = \"aut\"), person(\"Claus\", \"Wilke\", role = \"aut\", comment = c(ORCID = \"0000-0002-7470-9261\")), person(\"Kara\", \"Woo\", role = \"aut\", comment = c(ORCID = \"0000-0002-5125-4188\")), person(\"Hiroaki\", \"Yutani\", role = \"aut\", comment = c(ORCID = \"0000-0002-3385-7233\")), person(\"Dewey\", \"Dunnington\", role = \"aut\", comment = c(ORCID = \"0000-0002-9415-4582\")), person(\"Teun\", \"van den Brand\", role = \"aut\", comment = c(ORCID = \"0000-0002-9335-7468\")), person(\"Posit, PBC\", role = c(\"cph\", \"fnd\"), comment = c(ROR = \"03wc8by49\")) )", + "Description": "A system for 'declaratively' creating graphics, based on \"The Grammar of Graphics\". You provide the data, tell 'ggplot2' how to map variables to aesthetics, what graphical primitives to use, and it takes care of the details.", + "License": "MIT + file LICENSE", + "URL": "https://ggplot2.tidyverse.org, https://github.com/tidyverse/ggplot2", + "BugReports": "https://github.com/tidyverse/ggplot2/issues", + "Depends": [ + "R (>= 4.1)" + ], + "Imports": [ + "cli", + "grDevices", + "grid", + "gtable (>= 0.3.6)", + "isoband", + "lifecycle (> 1.0.1)", + "rlang (>= 1.1.0)", + "S7", + "scales (>= 1.4.0)", + "stats", + "vctrs (>= 0.6.0)", + "withr (>= 2.5.0)" + ], + "Suggests": [ + "broom", + "covr", + "dplyr", + "ggplot2movies", + "hexbin", + "Hmisc", + "knitr", + "mapproj", + "maps", + "MASS", + "mgcv", + "multcomp", + "munsell", + "nlme", + "profvis", + "quantreg", + "ragg (>= 1.2.6)", + "RColorBrewer", + "rmarkdown", + "roxygen2", + "rpart", + "sf (>= 0.7-3)", + "svglite (>= 2.1.2)", + "testthat (>= 3.1.5)", + "tibble", + "vdiffr (>= 1.0.6)", + "xml2" + ], + "Enhances": [ + "sp" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "ggtext, tidyr, forcats, tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/usethis/last-upkeep": "2025-04-23", + "Encoding": "UTF-8", + "LazyData": "true", + "RoxygenNote": "7.3.2", + "Collate": "'ggproto.R' 'ggplot-global.R' 'aaa-.R' 'aes-colour-fill-alpha.R' 'aes-evaluation.R' 'aes-group-order.R' 'aes-linetype-size-shape.R' 'aes-position.R' 'all-classes.R' 'compat-plyr.R' 'utilities.R' 'aes.R' 'annotation-borders.R' 'utilities-checks.R' 'legend-draw.R' 'geom-.R' 'annotation-custom.R' 'annotation-logticks.R' 'scale-type.R' 'layer.R' 'make-constructor.R' 'geom-polygon.R' 'geom-map.R' 'annotation-map.R' 'geom-raster.R' 'annotation-raster.R' 'annotation.R' 'autolayer.R' 'autoplot.R' 'axis-secondary.R' 'backports.R' 'bench.R' 'bin.R' 'coord-.R' 'coord-cartesian-.R' 'coord-fixed.R' 'coord-flip.R' 'coord-map.R' 'coord-munch.R' 'coord-polar.R' 'coord-quickmap.R' 'coord-radial.R' 'coord-sf.R' 'coord-transform.R' 'data.R' 'docs_layer.R' 'facet-.R' 'facet-grid-.R' 'facet-null.R' 'facet-wrap.R' 'fortify-map.R' 'fortify-models.R' 'fortify-spatial.R' 'fortify.R' 'stat-.R' 'geom-abline.R' 'geom-rect.R' 'geom-bar.R' 'geom-tile.R' 'geom-bin2d.R' 'geom-blank.R' 'geom-boxplot.R' 'geom-col.R' 'geom-path.R' 'geom-contour.R' 'geom-point.R' 'geom-count.R' 'geom-crossbar.R' 'geom-segment.R' 'geom-curve.R' 'geom-defaults.R' 'geom-ribbon.R' 'geom-density.R' 'geom-density2d.R' 'geom-dotplot.R' 'geom-errorbar.R' 'geom-freqpoly.R' 'geom-function.R' 'geom-hex.R' 'geom-histogram.R' 'geom-hline.R' 'geom-jitter.R' 'geom-label.R' 'geom-linerange.R' 'geom-pointrange.R' 'geom-quantile.R' 'geom-rug.R' 'geom-sf.R' 'geom-smooth.R' 'geom-spoke.R' 'geom-text.R' 'geom-violin.R' 'geom-vline.R' 'ggplot2-package.R' 'grob-absolute.R' 'grob-dotstack.R' 'grob-null.R' 'grouping.R' 'properties.R' 'margins.R' 'theme-elements.R' 'guide-.R' 'guide-axis.R' 'guide-axis-logticks.R' 'guide-axis-stack.R' 'guide-axis-theta.R' 'guide-legend.R' 'guide-bins.R' 'guide-colorbar.R' 'guide-colorsteps.R' 'guide-custom.R' 'guide-none.R' 'guide-old.R' 'guides-.R' 'guides-grid.R' 'hexbin.R' 'import-standalone-obj-type.R' 'import-standalone-types-check.R' 'labeller.R' 'labels.R' 'layer-sf.R' 'layout.R' 'limits.R' 'performance.R' 'plot-build.R' 'plot-construction.R' 'plot-last.R' 'plot.R' 'position-.R' 'position-collide.R' 'position-dodge.R' 'position-dodge2.R' 'position-identity.R' 'position-jitter.R' 'position-jitterdodge.R' 'position-nudge.R' 'position-stack.R' 'quick-plot.R' 'reshape-add-margins.R' 'save.R' 'scale-.R' 'scale-alpha.R' 'scale-binned.R' 'scale-brewer.R' 'scale-colour.R' 'scale-continuous.R' 'scale-date.R' 'scale-discrete-.R' 'scale-expansion.R' 'scale-gradient.R' 'scale-grey.R' 'scale-hue.R' 'scale-identity.R' 'scale-linetype.R' 'scale-linewidth.R' 'scale-manual.R' 'scale-shape.R' 'scale-size.R' 'scale-steps.R' 'scale-view.R' 'scale-viridis.R' 'scales-.R' 'stat-align.R' 'stat-bin.R' 'stat-summary-2d.R' 'stat-bin2d.R' 'stat-bindot.R' 'stat-binhex.R' 'stat-boxplot.R' 'stat-connect.R' 'stat-contour.R' 'stat-count.R' 'stat-density-2d.R' 'stat-density.R' 'stat-ecdf.R' 'stat-ellipse.R' 'stat-function.R' 'stat-identity.R' 'stat-manual.R' 'stat-qq-line.R' 'stat-qq.R' 'stat-quantilemethods.R' 'stat-sf-coordinates.R' 'stat-sf.R' 'stat-smooth-methods.R' 'stat-smooth.R' 'stat-sum.R' 'stat-summary-bin.R' 'stat-summary-hex.R' 'stat-summary.R' 'stat-unique.R' 'stat-ydensity.R' 'summarise-plot.R' 'summary.R' 'theme.R' 'theme-defaults.R' 'theme-current.R' 'theme-sub.R' 'utilities-break.R' 'utilities-grid.R' 'utilities-help.R' 'utilities-patterns.R' 'utilities-resolution.R' 'utilities-tidy-eval.R' 'zxx.R' 'zzz.R'", + "NeedsCompilation": "no", + "Author": "Hadley Wickham [aut] (ORCID: ), Winston Chang [aut] (ORCID: ), Lionel Henry [aut], Thomas Lin Pedersen [aut, cre] (ORCID: ), Kohske Takahashi [aut], Claus Wilke [aut] (ORCID: ), Kara Woo [aut] (ORCID: ), Hiroaki Yutani [aut] (ORCID: ), Dewey Dunnington [aut] (ORCID: ), Teun van den Brand [aut] (ORCID: ), Posit, PBC [cph, fnd] (ROR: )", + "Maintainer": "Thomas Lin Pedersen ", + "Repository": "CRAN" + }, + "glue": { + "Package": "glue", + "Version": "1.8.0", + "Source": "Repository", + "Title": "Interpreted String Literals", + "Authors@R": "c( person(\"Jim\", \"Hester\", role = \"aut\", comment = c(ORCID = \"0000-0002-2739-7082\")), person(\"Jennifer\", \"Bryan\", , \"jenny@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-6983-2759\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "An implementation of interpreted string literals, inspired by Python's Literal String Interpolation and Docstrings and Julia's Triple-Quoted String Literals .", + "License": "MIT + file LICENSE", + "URL": "https://glue.tidyverse.org/, https://github.com/tidyverse/glue", + "BugReports": "https://github.com/tidyverse/glue/issues", + "Depends": [ + "R (>= 3.6)" + ], + "Imports": [ + "methods" + ], + "Suggests": [ + "crayon", + "DBI (>= 1.2.0)", + "dplyr", + "knitr", + "magrittr", + "rlang", + "rmarkdown", + "RSQLite", + "testthat (>= 3.2.0)", + "vctrs (>= 0.3.0)", + "waldo (>= 0.5.3)", + "withr" + ], + "VignetteBuilder": "knitr", + "ByteCompile": "true", + "Config/Needs/website": "bench, forcats, ggbeeswarm, ggplot2, R.utils, rprintf, tidyr, tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "yes", + "Author": "Jim Hester [aut] (), Jennifer Bryan [aut, cre] (), Posit Software, PBC [cph, fnd]", + "Maintainer": "Jennifer Bryan ", + "Repository": "CRAN" + }, + "gtable": { + "Package": "gtable", + "Version": "0.3.6", + "Source": "Repository", + "Title": "Arrange 'Grobs' in Tables", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Thomas Lin\", \"Pedersen\", , \"thomas.pedersen@posit.co\", role = c(\"aut\", \"cre\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Tools to make it easier to work with \"tables\" of 'grobs'. The 'gtable' package defines a 'gtable' grob class that specifies a grid along with a list of grobs and their placement in the grid. Further the package makes it easy to manipulate and combine 'gtable' objects so that complex compositions can be built up sequentially.", + "License": "MIT + file LICENSE", + "URL": "https://gtable.r-lib.org, https://github.com/r-lib/gtable", + "BugReports": "https://github.com/r-lib/gtable/issues", + "Depends": [ + "R (>= 4.0)" + ], + "Imports": [ + "cli", + "glue", + "grid", + "lifecycle", + "rlang (>= 1.1.0)", + "stats" + ], + "Suggests": [ + "covr", + "ggplot2", + "knitr", + "profvis", + "rmarkdown", + "testthat (>= 3.0.0)" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/usethis/last-upkeep": "2024-10-25", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Hadley Wickham [aut], Thomas Lin Pedersen [aut, cre], Posit Software, PBC [cph, fnd]", + "Maintainer": "Thomas Lin Pedersen ", + "Repository": "CRAN" + }, + "highr": { + "Package": "highr", + "Version": "0.11", + "Source": "Repository", + "Type": "Package", + "Title": "Syntax Highlighting for R Source Code", + "Authors@R": "c( person(\"Yihui\", \"Xie\", role = c(\"aut\", \"cre\"), email = \"xie@yihui.name\", comment = c(ORCID = \"0000-0003-0645-5666\")), person(\"Yixuan\", \"Qiu\", role = \"aut\"), person(\"Christopher\", \"Gandrud\", role = \"ctb\"), person(\"Qiang\", \"Li\", role = \"ctb\") )", + "Description": "Provides syntax highlighting for R source code. Currently it supports LaTeX and HTML output. Source code of other languages is supported via Andre Simon's highlight package ().", + "Depends": [ + "R (>= 3.3.0)" + ], + "Imports": [ + "xfun (>= 0.18)" + ], + "Suggests": [ + "knitr", + "markdown", + "testit" + ], + "License": "GPL", + "URL": "https://github.com/yihui/highr", + "BugReports": "https://github.com/yihui/highr/issues", + "VignetteBuilder": "knitr", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.1", + "NeedsCompilation": "no", + "Author": "Yihui Xie [aut, cre] (), Yixuan Qiu [aut], Christopher Gandrud [ctb], Qiang Li [ctb]", + "Maintainer": "Yihui Xie ", + "Repository": "CRAN" + }, + "htmltools": { + "Package": "htmltools", + "Version": "0.5.8.1", + "Source": "Repository", + "Type": "Package", + "Title": "Tools for HTML", + "Authors@R": "c( person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = \"aut\"), person(\"Carson\", \"Sievert\", , \"carson@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Barret\", \"Schloerke\", , \"barret@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0001-9986-114X\")), person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0002-1576-2126\")), person(\"Yihui\", \"Xie\", , \"yihui@posit.co\", role = \"aut\"), person(\"Jeff\", \"Allen\", role = \"aut\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Tools for HTML generation and output.", + "License": "GPL (>= 2)", + "URL": "https://github.com/rstudio/htmltools, https://rstudio.github.io/htmltools/", + "BugReports": "https://github.com/rstudio/htmltools/issues", + "Depends": [ + "R (>= 2.14.1)" + ], + "Imports": [ + "base64enc", + "digest", + "fastmap (>= 1.1.0)", + "grDevices", + "rlang (>= 1.0.0)", + "utils" + ], + "Suggests": [ + "Cairo", + "markdown", + "ragg", + "shiny", + "testthat", + "withr" + ], + "Enhances": [ + "knitr" + ], + "Config/Needs/check": "knitr", + "Config/Needs/website": "rstudio/quillt, bench", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.1", + "Collate": "'colors.R' 'fill.R' 'html_dependency.R' 'html_escape.R' 'html_print.R' 'htmltools-package.R' 'images.R' 'known_tags.R' 'selector.R' 'staticimports.R' 'tag_query.R' 'utils.R' 'tags.R' 'template.R'", + "NeedsCompilation": "yes", + "Author": "Joe Cheng [aut], Carson Sievert [aut, cre] (), Barret Schloerke [aut] (), Winston Chang [aut] (), Yihui Xie [aut], Jeff Allen [aut], Posit Software, PBC [cph, fnd]", + "Maintainer": "Carson Sievert ", + "Repository": "CRAN" + }, + "httpuv": { + "Package": "httpuv", + "Version": "1.6.16", + "Source": "Repository", + "Type": "Package", + "Title": "HTTP and WebSocket Server Library", + "Authors@R": "c( person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = \"aut\"), person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = c(\"aut\", \"cre\")), person(\"Posit, PBC\", \"fnd\", role = \"cph\"), person(\"Hector\", \"Corrada Bravo\", role = \"ctb\"), person(\"Jeroen\", \"Ooms\", role = \"ctb\"), person(\"Andrzej\", \"Krzemienski\", role = \"cph\", comment = \"optional.hpp\"), person(\"libuv project contributors\", role = \"cph\", comment = \"libuv library, see src/libuv/AUTHORS file\"), person(\"Joyent, Inc. and other Node contributors\", role = \"cph\", comment = \"libuv library, see src/libuv/AUTHORS file; and http-parser library, see src/http-parser/AUTHORS file\"), person(\"Niels\", \"Provos\", role = \"cph\", comment = \"libuv subcomponent: tree.h\"), person(\"Internet Systems Consortium, Inc.\", role = \"cph\", comment = \"libuv subcomponent: inet_pton and inet_ntop, contained in src/libuv/src/inet.c\"), person(\"Alexander\", \"Chemeris\", role = \"cph\", comment = \"libuv subcomponent: stdint-msvc2008.h (from msinttypes)\"), person(\"Google, Inc.\", role = \"cph\", comment = \"libuv subcomponent: pthread-fixes.c\"), person(\"Sony Mobile Communcations AB\", role = \"cph\", comment = \"libuv subcomponent: pthread-fixes.c\"), person(\"Berkeley Software Design Inc.\", role = \"cph\", comment = \"libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c\"), person(\"Kenneth\", \"MacKay\", role = \"cph\", comment = \"libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c\"), person(\"Emergya (Cloud4all, FP7/2007-2013, grant agreement no 289016)\", role = \"cph\", comment = \"libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c\"), person(\"Steve\", \"Reid\", role = \"aut\", comment = \"SHA-1 implementation\"), person(\"James\", \"Brown\", role = \"aut\", comment = \"SHA-1 implementation\"), person(\"Bob\", \"Trower\", role = \"aut\", comment = \"base64 implementation\"), person(\"Alexander\", \"Peslyak\", role = \"aut\", comment = \"MD5 implementation\"), person(\"Trantor Standard Systems\", role = \"cph\", comment = \"base64 implementation\"), person(\"Igor\", \"Sysoev\", role = \"cph\", comment = \"http-parser\") )", + "Description": "Provides low-level socket and protocol support for handling HTTP and WebSocket requests directly from within R. It is primarily intended as a building block for other packages, rather than making it particularly easy to create complete web applications using httpuv alone. httpuv is built on top of the libuv and http-parser C libraries, both of which were developed by Joyent, Inc. (See LICENSE file for libuv and http-parser license information.)", + "License": "GPL (>= 2) | file LICENSE", + "URL": "https://github.com/rstudio/httpuv", + "BugReports": "https://github.com/rstudio/httpuv/issues", + "Depends": [ + "R (>= 2.15.1)" + ], + "Imports": [ + "later (>= 0.8.0)", + "promises", + "R6", + "Rcpp (>= 1.0.7)", + "utils" + ], + "Suggests": [ + "callr", + "curl", + "jsonlite", + "testthat", + "websocket" + ], + "LinkingTo": [ + "later", + "Rcpp" + ], + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "SystemRequirements": "GNU make, zlib", + "Collate": "'RcppExports.R' 'httpuv.R' 'random_port.R' 'server.R' 'staticServer.R' 'static_paths.R' 'utils.R'", + "NeedsCompilation": "yes", + "Author": "Joe Cheng [aut], Winston Chang [aut, cre], Posit, PBC fnd [cph], Hector Corrada Bravo [ctb], Jeroen Ooms [ctb], Andrzej Krzemienski [cph] (optional.hpp), libuv project contributors [cph] (libuv library, see src/libuv/AUTHORS file), Joyent, Inc. and other Node contributors [cph] (libuv library, see src/libuv/AUTHORS file; and http-parser library, see src/http-parser/AUTHORS file), Niels Provos [cph] (libuv subcomponent: tree.h), Internet Systems Consortium, Inc. [cph] (libuv subcomponent: inet_pton and inet_ntop, contained in src/libuv/src/inet.c), Alexander Chemeris [cph] (libuv subcomponent: stdint-msvc2008.h (from msinttypes)), Google, Inc. [cph] (libuv subcomponent: pthread-fixes.c), Sony Mobile Communcations AB [cph] (libuv subcomponent: pthread-fixes.c), Berkeley Software Design Inc. [cph] (libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c), Kenneth MacKay [cph] (libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c), Emergya (Cloud4all, FP7/2007-2013, grant agreement no 289016) [cph] (libuv subcomponent: android-ifaddrs.h, android-ifaddrs.c), Steve Reid [aut] (SHA-1 implementation), James Brown [aut] (SHA-1 implementation), Bob Trower [aut] (base64 implementation), Alexander Peslyak [aut] (MD5 implementation), Trantor Standard Systems [cph] (base64 implementation), Igor Sysoev [cph] (http-parser)", + "Maintainer": "Winston Chang ", + "Repository": "RSPM" + }, + "isoband": { + "Package": "isoband", + "Version": "0.2.7", + "Source": "Repository", + "Title": "Generate Isolines and Isobands from Regularly Spaced Elevation Grids", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0003-4757-117X\")), person(\"Claus O.\", \"Wilke\", , \"wilke@austin.utexas.edu\", role = \"aut\", comment = c(\"Original author\", ORCID = \"0000-0002-7470-9261\")), person(\"Thomas Lin\", \"Pedersen\", , \"thomasp85@gmail.com\", role = \"aut\", comment = c(ORCID = \"0000-0002-5147-4711\")) )", + "Description": "A fast C++ implementation to generate contour lines (isolines) and contour polygons (isobands) from regularly spaced grids containing elevation data.", + "License": "MIT + file LICENSE", + "URL": "https://isoband.r-lib.org", + "BugReports": "https://github.com/r-lib/isoband/issues", + "Imports": [ + "grid", + "utils" + ], + "Suggests": [ + "covr", + "ggplot2", + "knitr", + "magick", + "microbenchmark", + "rmarkdown", + "sf", + "testthat", + "xml2" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.2.3", + "SystemRequirements": "C++11", + "NeedsCompilation": "yes", + "Author": "Hadley Wickham [aut, cre] (), Claus O. Wilke [aut] (Original author, ), Thomas Lin Pedersen [aut] ()", + "Maintainer": "Hadley Wickham ", + "Repository": "CRAN" + }, + "jquerylib": { + "Package": "jquerylib", + "Version": "0.1.4", + "Source": "Repository", + "Title": "Obtain 'jQuery' as an HTML Dependency Object", + "Authors@R": "c( person(\"Carson\", \"Sievert\", role = c(\"aut\", \"cre\"), email = \"carson@rstudio.com\", comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Joe\", \"Cheng\", role = \"aut\", email = \"joe@rstudio.com\"), person(family = \"RStudio\", role = \"cph\"), person(family = \"jQuery Foundation\", role = \"cph\", comment = \"jQuery library and jQuery UI library\"), person(family = \"jQuery contributors\", role = c(\"ctb\", \"cph\"), comment = \"jQuery library; authors listed in inst/lib/jquery-AUTHORS.txt\") )", + "Description": "Obtain any major version of 'jQuery' () and use it in any webpage generated by 'htmltools' (e.g. 'shiny', 'htmlwidgets', and 'rmarkdown'). Most R users don't need to use this package directly, but other R packages (e.g. 'shiny', 'rmarkdown', etc.) depend on this package to avoid bundling redundant copies of 'jQuery'.", + "License": "MIT + file LICENSE", + "Encoding": "UTF-8", + "Config/testthat/edition": "3", + "RoxygenNote": "7.0.2", + "Imports": [ + "htmltools" + ], + "Suggests": [ + "testthat" + ], + "NeedsCompilation": "no", + "Author": "Carson Sievert [aut, cre] (), Joe Cheng [aut], RStudio [cph], jQuery Foundation [cph] (jQuery library and jQuery UI library), jQuery contributors [ctb, cph] (jQuery library; authors listed in inst/lib/jquery-AUTHORS.txt)", + "Maintainer": "Carson Sievert ", + "Repository": "CRAN" + }, + "jsonlite": { + "Package": "jsonlite", + "Version": "2.0.0", + "Source": "Repository", + "Title": "A Simple and Robust JSON Parser and Generator for R", + "License": "MIT + file LICENSE", + "Depends": [ + "methods" + ], + "Authors@R": "c( person(\"Jeroen\", \"Ooms\", role = c(\"aut\", \"cre\"), email = \"jeroenooms@gmail.com\", comment = c(ORCID = \"0000-0002-4035-0289\")), person(\"Duncan\", \"Temple Lang\", role = \"ctb\"), person(\"Lloyd\", \"Hilaiel\", role = \"cph\", comment=\"author of bundled libyajl\"))", + "URL": "https://jeroen.r-universe.dev/jsonlite https://arxiv.org/abs/1403.2805", + "BugReports": "https://github.com/jeroen/jsonlite/issues", + "Maintainer": "Jeroen Ooms ", + "VignetteBuilder": "knitr, R.rsp", + "Description": "A reasonably fast JSON parser and generator, optimized for statistical data and the web. Offers simple, flexible tools for working with JSON in R, and is particularly powerful for building pipelines and interacting with a web API. The implementation is based on the mapping described in the vignette (Ooms, 2014). In addition to converting JSON data from/to R objects, 'jsonlite' contains functions to stream, validate, and prettify JSON data. The unit tests included with the package verify that all edge cases are encoded and decoded consistently for use with dynamic data in systems and applications.", + "Suggests": [ + "httr", + "vctrs", + "testthat", + "knitr", + "rmarkdown", + "R.rsp", + "sf" + ], + "RoxygenNote": "7.3.2", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Author": "Jeroen Ooms [aut, cre] (), Duncan Temple Lang [ctb], Lloyd Hilaiel [cph] (author of bundled libyajl)", + "Repository": "CRAN" + }, + "knitr": { + "Package": "knitr", + "Version": "1.50", + "Source": "Repository", + "Type": "Package", + "Title": "A General-Purpose Package for Dynamic Report Generation in R", + "Authors@R": "c( person(\"Yihui\", \"Xie\", role = c(\"aut\", \"cre\"), email = \"xie@yihui.name\", comment = c(ORCID = \"0000-0003-0645-5666\", URL = \"https://yihui.org\")), person(\"Abhraneel\", \"Sarma\", role = \"ctb\"), person(\"Adam\", \"Vogt\", role = \"ctb\"), person(\"Alastair\", \"Andrew\", role = \"ctb\"), person(\"Alex\", \"Zvoleff\", role = \"ctb\"), person(\"Amar\", \"Al-Zubaidi\", role = \"ctb\"), person(\"Andre\", \"Simon\", role = \"ctb\", comment = \"the CSS files under inst/themes/ were derived from the Highlight package http://www.andre-simon.de\"), person(\"Aron\", \"Atkins\", role = \"ctb\"), person(\"Aaron\", \"Wolen\", role = \"ctb\"), person(\"Ashley\", \"Manton\", role = \"ctb\"), person(\"Atsushi\", \"Yasumoto\", role = \"ctb\", comment = c(ORCID = \"0000-0002-8335-495X\")), person(\"Ben\", \"Baumer\", role = \"ctb\"), person(\"Brian\", \"Diggs\", role = \"ctb\"), person(\"Brian\", \"Zhang\", role = \"ctb\"), person(\"Bulat\", \"Yapparov\", role = \"ctb\"), person(\"Cassio\", \"Pereira\", role = \"ctb\"), person(\"Christophe\", \"Dervieux\", role = \"ctb\"), person(\"David\", \"Hall\", role = \"ctb\"), person(\"David\", \"Hugh-Jones\", role = \"ctb\"), person(\"David\", \"Robinson\", role = \"ctb\"), person(\"Doug\", \"Hemken\", role = \"ctb\"), person(\"Duncan\", \"Murdoch\", role = \"ctb\"), person(\"Elio\", \"Campitelli\", role = \"ctb\"), person(\"Ellis\", \"Hughes\", role = \"ctb\"), person(\"Emily\", \"Riederer\", role = \"ctb\"), person(\"Fabian\", \"Hirschmann\", role = \"ctb\"), person(\"Fitch\", \"Simeon\", role = \"ctb\"), person(\"Forest\", \"Fang\", role = \"ctb\"), person(c(\"Frank\", \"E\", \"Harrell\", \"Jr\"), role = \"ctb\", comment = \"the Sweavel package at inst/misc/Sweavel.sty\"), person(\"Garrick\", \"Aden-Buie\", role = \"ctb\"), person(\"Gregoire\", \"Detrez\", role = \"ctb\"), person(\"Hadley\", \"Wickham\", role = \"ctb\"), person(\"Hao\", \"Zhu\", role = \"ctb\"), person(\"Heewon\", \"Jeon\", role = \"ctb\"), person(\"Henrik\", \"Bengtsson\", role = \"ctb\"), person(\"Hiroaki\", \"Yutani\", role = \"ctb\"), person(\"Ian\", \"Lyttle\", role = \"ctb\"), person(\"Hodges\", \"Daniel\", role = \"ctb\"), person(\"Jacob\", \"Bien\", role = \"ctb\"), person(\"Jake\", \"Burkhead\", role = \"ctb\"), person(\"James\", \"Manton\", role = \"ctb\"), person(\"Jared\", \"Lander\", role = \"ctb\"), person(\"Jason\", \"Punyon\", role = \"ctb\"), person(\"Javier\", \"Luraschi\", role = \"ctb\"), person(\"Jeff\", \"Arnold\", role = \"ctb\"), person(\"Jenny\", \"Bryan\", role = \"ctb\"), person(\"Jeremy\", \"Ashkenas\", role = c(\"ctb\", \"cph\"), comment = \"the CSS file at inst/misc/docco-classic.css\"), person(\"Jeremy\", \"Stephens\", role = \"ctb\"), person(\"Jim\", \"Hester\", role = \"ctb\"), person(\"Joe\", \"Cheng\", role = \"ctb\"), person(\"Johannes\", \"Ranke\", role = \"ctb\"), person(\"John\", \"Honaker\", role = \"ctb\"), person(\"John\", \"Muschelli\", role = \"ctb\"), person(\"Jonathan\", \"Keane\", role = \"ctb\"), person(\"JJ\", \"Allaire\", role = \"ctb\"), person(\"Johan\", \"Toloe\", role = \"ctb\"), person(\"Jonathan\", \"Sidi\", role = \"ctb\"), person(\"Joseph\", \"Larmarange\", role = \"ctb\"), person(\"Julien\", \"Barnier\", role = \"ctb\"), person(\"Kaiyin\", \"Zhong\", role = \"ctb\"), person(\"Kamil\", \"Slowikowski\", role = \"ctb\"), person(\"Karl\", \"Forner\", role = \"ctb\"), person(c(\"Kevin\", \"K.\"), \"Smith\", role = \"ctb\"), person(\"Kirill\", \"Mueller\", role = \"ctb\"), person(\"Kohske\", \"Takahashi\", role = \"ctb\"), person(\"Lorenz\", \"Walthert\", role = \"ctb\"), person(\"Lucas\", \"Gallindo\", role = \"ctb\"), person(\"Marius\", \"Hofert\", role = \"ctb\"), person(\"Martin\", \"Modrák\", role = \"ctb\"), person(\"Michael\", \"Chirico\", role = \"ctb\"), person(\"Michael\", \"Friendly\", role = \"ctb\"), person(\"Michal\", \"Bojanowski\", role = \"ctb\"), person(\"Michel\", \"Kuhlmann\", role = \"ctb\"), person(\"Miller\", \"Patrick\", role = \"ctb\"), person(\"Nacho\", \"Caballero\", role = \"ctb\"), person(\"Nick\", \"Salkowski\", role = \"ctb\"), person(\"Niels Richard\", \"Hansen\", role = \"ctb\"), person(\"Noam\", \"Ross\", role = \"ctb\"), person(\"Obada\", \"Mahdi\", role = \"ctb\"), person(\"Pavel N.\", \"Krivitsky\", role = \"ctb\", comment=c(ORCID = \"0000-0002-9101-3362\")), person(\"Pedro\", \"Faria\", role = \"ctb\"), person(\"Qiang\", \"Li\", role = \"ctb\"), person(\"Ramnath\", \"Vaidyanathan\", role = \"ctb\"), person(\"Richard\", \"Cotton\", role = \"ctb\"), person(\"Robert\", \"Krzyzanowski\", role = \"ctb\"), person(\"Rodrigo\", \"Copetti\", role = \"ctb\"), person(\"Romain\", \"Francois\", role = \"ctb\"), person(\"Ruaridh\", \"Williamson\", role = \"ctb\"), person(\"Sagiru\", \"Mati\", role = \"ctb\", comment = c(ORCID = \"0000-0003-1413-3974\")), person(\"Scott\", \"Kostyshak\", role = \"ctb\"), person(\"Sebastian\", \"Meyer\", role = \"ctb\"), person(\"Sietse\", \"Brouwer\", role = \"ctb\"), person(c(\"Simon\", \"de\"), \"Bernard\", role = \"ctb\"), person(\"Sylvain\", \"Rousseau\", role = \"ctb\"), person(\"Taiyun\", \"Wei\", role = \"ctb\"), person(\"Thibaut\", \"Assus\", role = \"ctb\"), person(\"Thibaut\", \"Lamadon\", role = \"ctb\"), person(\"Thomas\", \"Leeper\", role = \"ctb\"), person(\"Tim\", \"Mastny\", role = \"ctb\"), person(\"Tom\", \"Torsney-Weir\", role = \"ctb\"), person(\"Trevor\", \"Davis\", role = \"ctb\"), person(\"Viktoras\", \"Veitas\", role = \"ctb\"), person(\"Weicheng\", \"Zhu\", role = \"ctb\"), person(\"Wush\", \"Wu\", role = \"ctb\"), person(\"Zachary\", \"Foster\", role = \"ctb\"), person(\"Zhian N.\", \"Kamvar\", role = \"ctb\", comment = c(ORCID = \"0000-0003-1458-7108\")), person(given = \"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Provides a general-purpose tool for dynamic report generation in R using Literate Programming techniques.", + "Depends": [ + "R (>= 3.6.0)" + ], + "Imports": [ + "evaluate (>= 0.15)", + "highr (>= 0.11)", + "methods", + "tools", + "xfun (>= 0.51)", + "yaml (>= 2.1.19)" + ], + "Suggests": [ + "bslib", + "codetools", + "DBI (>= 0.4-1)", + "digest", + "formatR", + "gifski", + "gridSVG", + "htmlwidgets (>= 0.7)", + "jpeg", + "JuliaCall (>= 0.11.1)", + "magick", + "litedown", + "markdown (>= 1.3)", + "png", + "ragg", + "reticulate (>= 1.4)", + "rgl (>= 0.95.1201)", + "rlang", + "rmarkdown", + "sass", + "showtext", + "styler (>= 1.2.0)", + "targets (>= 0.6.0)", + "testit", + "tibble", + "tikzDevice (>= 0.10)", + "tinytex (>= 0.56)", + "webshot", + "rstudioapi", + "svglite" + ], + "License": "GPL", + "URL": "https://yihui.org/knitr/", + "BugReports": "https://github.com/yihui/knitr/issues", + "Encoding": "UTF-8", + "VignetteBuilder": "litedown, knitr", + "SystemRequirements": "Package vignettes based on R Markdown v2 or reStructuredText require Pandoc (http://pandoc.org). The function rst2pdf() requires rst2pdf (https://github.com/rst2pdf/rst2pdf).", + "Collate": "'block.R' 'cache.R' 'citation.R' 'hooks-html.R' 'plot.R' 'utils.R' 'defaults.R' 'concordance.R' 'engine.R' 'highlight.R' 'themes.R' 'header.R' 'hooks-asciidoc.R' 'hooks-chunk.R' 'hooks-extra.R' 'hooks-latex.R' 'hooks-md.R' 'hooks-rst.R' 'hooks-textile.R' 'hooks.R' 'output.R' 'package.R' 'pandoc.R' 'params.R' 'parser.R' 'pattern.R' 'rocco.R' 'spin.R' 'table.R' 'template.R' 'utils-conversion.R' 'utils-rd2html.R' 'utils-string.R' 'utils-sweave.R' 'utils-upload.R' 'utils-vignettes.R' 'zzz.R'", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Yihui Xie [aut, cre] (, https://yihui.org), Abhraneel Sarma [ctb], Adam Vogt [ctb], Alastair Andrew [ctb], Alex Zvoleff [ctb], Amar Al-Zubaidi [ctb], Andre Simon [ctb] (the CSS files under inst/themes/ were derived from the Highlight package http://www.andre-simon.de), Aron Atkins [ctb], Aaron Wolen [ctb], Ashley Manton [ctb], Atsushi Yasumoto [ctb] (), Ben Baumer [ctb], Brian Diggs [ctb], Brian Zhang [ctb], Bulat Yapparov [ctb], Cassio Pereira [ctb], Christophe Dervieux [ctb], David Hall [ctb], David Hugh-Jones [ctb], David Robinson [ctb], Doug Hemken [ctb], Duncan Murdoch [ctb], Elio Campitelli [ctb], Ellis Hughes [ctb], Emily Riederer [ctb], Fabian Hirschmann [ctb], Fitch Simeon [ctb], Forest Fang [ctb], Frank E Harrell Jr [ctb] (the Sweavel package at inst/misc/Sweavel.sty), Garrick Aden-Buie [ctb], Gregoire Detrez [ctb], Hadley Wickham [ctb], Hao Zhu [ctb], Heewon Jeon [ctb], Henrik Bengtsson [ctb], Hiroaki Yutani [ctb], Ian Lyttle [ctb], Hodges Daniel [ctb], Jacob Bien [ctb], Jake Burkhead [ctb], James Manton [ctb], Jared Lander [ctb], Jason Punyon [ctb], Javier Luraschi [ctb], Jeff Arnold [ctb], Jenny Bryan [ctb], Jeremy Ashkenas [ctb, cph] (the CSS file at inst/misc/docco-classic.css), Jeremy Stephens [ctb], Jim Hester [ctb], Joe Cheng [ctb], Johannes Ranke [ctb], John Honaker [ctb], John Muschelli [ctb], Jonathan Keane [ctb], JJ Allaire [ctb], Johan Toloe [ctb], Jonathan Sidi [ctb], Joseph Larmarange [ctb], Julien Barnier [ctb], Kaiyin Zhong [ctb], Kamil Slowikowski [ctb], Karl Forner [ctb], Kevin K. Smith [ctb], Kirill Mueller [ctb], Kohske Takahashi [ctb], Lorenz Walthert [ctb], Lucas Gallindo [ctb], Marius Hofert [ctb], Martin Modrák [ctb], Michael Chirico [ctb], Michael Friendly [ctb], Michal Bojanowski [ctb], Michel Kuhlmann [ctb], Miller Patrick [ctb], Nacho Caballero [ctb], Nick Salkowski [ctb], Niels Richard Hansen [ctb], Noam Ross [ctb], Obada Mahdi [ctb], Pavel N. Krivitsky [ctb] (), Pedro Faria [ctb], Qiang Li [ctb], Ramnath Vaidyanathan [ctb], Richard Cotton [ctb], Robert Krzyzanowski [ctb], Rodrigo Copetti [ctb], Romain Francois [ctb], Ruaridh Williamson [ctb], Sagiru Mati [ctb] (), Scott Kostyshak [ctb], Sebastian Meyer [ctb], Sietse Brouwer [ctb], Simon de Bernard [ctb], Sylvain Rousseau [ctb], Taiyun Wei [ctb], Thibaut Assus [ctb], Thibaut Lamadon [ctb], Thomas Leeper [ctb], Tim Mastny [ctb], Tom Torsney-Weir [ctb], Trevor Davis [ctb], Viktoras Veitas [ctb], Weicheng Zhu [ctb], Wush Wu [ctb], Zachary Foster [ctb], Zhian N. Kamvar [ctb] (), Posit Software, PBC [cph, fnd]", + "Maintainer": "Yihui Xie ", + "Repository": "CRAN" + }, + "labeling": { + "Package": "labeling", + "Version": "0.4.3", + "Source": "Repository", + "Type": "Package", + "Title": "Axis Labeling", + "Date": "2023-08-29", + "Author": "Justin Talbot,", + "Maintainer": "Nuno Sempere ", + "Description": "Functions which provide a range of axis labeling algorithms.", + "License": "MIT + file LICENSE | Unlimited", + "Collate": "'labeling.R'", + "NeedsCompilation": "no", + "Imports": [ + "stats", + "graphics" + ], + "Repository": "CRAN" + }, + "later": { + "Package": "later", + "Version": "1.4.4", + "Source": "Repository", + "Type": "Package", + "Title": "Utilities for Scheduling Functions to Execute Later with Event Loops", + "Authors@R": "c( person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = \"aut\"), person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = \"aut\"), person(\"Charlie\", \"Gao\", , \"charlie.gao@posit.co\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-0750-061X\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\"), comment = c(ROR = \"03wc8by49\")), person(\"Marcus\", \"Geelnard\", role = c(\"ctb\", \"cph\"), comment = \"TinyCThread library, https://tinycthread.github.io/\"), person(\"Evan\", \"Nemerson\", role = c(\"ctb\", \"cph\"), comment = \"TinyCThread library, https://tinycthread.github.io/\") )", + "Description": "Executes arbitrary R or C functions some time after the current time, after the R execution stack has emptied. The functions are scheduled in an event loop.", + "License": "MIT + file LICENSE", + "URL": "https://later.r-lib.org, https://github.com/r-lib/later", + "BugReports": "https://github.com/r-lib/later/issues", + "Imports": [ + "Rcpp (>= 0.12.9)", + "rlang" + ], + "Suggests": [ + "knitr", + "nanonext", + "rmarkdown", + "testthat (>= 3.0.0)" + ], + "LinkingTo": [ + "Rcpp" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/usethis/last-upkeep": "2025-07-18", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "yes", + "Author": "Winston Chang [aut], Joe Cheng [aut], Charlie Gao [aut, cre] (ORCID: ), Posit Software, PBC [cph, fnd] (ROR: ), Marcus Geelnard [ctb, cph] (TinyCThread library, https://tinycthread.github.io/), Evan Nemerson [ctb, cph] (TinyCThread library, https://tinycthread.github.io/)", + "Maintainer": "Charlie Gao ", + "Repository": "RSPM" + }, + "lifecycle": { + "Package": "lifecycle", + "Version": "1.0.4", + "Source": "Repository", + "Title": "Manage the Life Cycle of your Package Functions", + "Authors@R": "c( person(\"Lionel\", \"Henry\", , \"lionel@posit.co\", role = c(\"aut\", \"cre\")), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0003-4757-117X\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Manage the life cycle of your exported functions with shared conventions, documentation badges, and user-friendly deprecation warnings.", + "License": "MIT + file LICENSE", + "URL": "https://lifecycle.r-lib.org/, https://github.com/r-lib/lifecycle", + "BugReports": "https://github.com/r-lib/lifecycle/issues", + "Depends": [ + "R (>= 3.6)" + ], + "Imports": [ + "cli (>= 3.4.0)", + "glue", + "rlang (>= 1.1.0)" + ], + "Suggests": [ + "covr", + "crayon", + "knitr", + "lintr", + "rmarkdown", + "testthat (>= 3.0.1)", + "tibble", + "tidyverse", + "tools", + "vctrs", + "withr" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate, usethis", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.2.1", + "NeedsCompilation": "no", + "Author": "Lionel Henry [aut, cre], Hadley Wickham [aut] (), Posit Software, PBC [cph, fnd]", + "Maintainer": "Lionel Henry ", + "Repository": "CRAN" + }, + "magrittr": { + "Package": "magrittr", + "Version": "2.0.4", + "Source": "Repository", + "Type": "Package", + "Title": "A Forward-Pipe Operator for R", + "Authors@R": "c( person(\"Stefan Milton\", \"Bache\", , \"stefan@stefanbache.dk\", role = c(\"aut\", \"cph\"), comment = \"Original author and creator of magrittr\"), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Lionel\", \"Henry\", , \"lionel@posit.co\", role = \"cre\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\"), comment = c(ROR = \"03wc8by49\")) )", + "Description": "Provides a mechanism for chaining commands with a new forward-pipe operator, %>%. This operator will forward a value, or the result of an expression, into the next function call/expression. There is flexible support for the type of right-hand side expressions. For more information, see package vignette. To quote Rene Magritte, \"Ceci n'est pas un pipe.\"", + "License": "MIT + file LICENSE", + "URL": "https://magrittr.tidyverse.org, https://github.com/tidyverse/magrittr", + "BugReports": "https://github.com/tidyverse/magrittr/issues", + "Depends": [ + "R (>= 3.4.0)" + ], + "Suggests": [ + "covr", + "knitr", + "rlang", + "rmarkdown", + "testthat" + ], + "VignetteBuilder": "knitr", + "ByteCompile": "Yes", + "Config/Needs/website": "tidyverse/tidytemplate", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.3", + "NeedsCompilation": "yes", + "Author": "Stefan Milton Bache [aut, cph] (Original author and creator of magrittr), Hadley Wickham [aut], Lionel Henry [cre], Posit Software, PBC [cph, fnd] (ROR: )", + "Maintainer": "Lionel Henry ", + "Repository": "RSPM" + }, + "memoise": { + "Package": "memoise", + "Version": "2.0.1", + "Source": "Repository", + "Title": "'Memoisation' of Functions", + "Authors@R": "c(person(given = \"Hadley\", family = \"Wickham\", role = \"aut\", email = \"hadley@rstudio.com\"), person(given = \"Jim\", family = \"Hester\", role = \"aut\"), person(given = \"Winston\", family = \"Chang\", role = c(\"aut\", \"cre\"), email = \"winston@rstudio.com\"), person(given = \"Kirill\", family = \"Müller\", role = \"aut\", email = \"krlmlr+r@mailbox.org\"), person(given = \"Daniel\", family = \"Cook\", role = \"aut\", email = \"danielecook@gmail.com\"), person(given = \"Mark\", family = \"Edmondson\", role = \"ctb\", email = \"r@sunholo.com\"))", + "Description": "Cache the results of a function so that when you call it again with the same arguments it returns the previously computed value.", + "License": "MIT + file LICENSE", + "URL": "https://memoise.r-lib.org, https://github.com/r-lib/memoise", + "BugReports": "https://github.com/r-lib/memoise/issues", + "Imports": [ + "rlang (>= 0.4.10)", + "cachem" + ], + "Suggests": [ + "digest", + "aws.s3", + "covr", + "googleAuthR", + "googleCloudStorageR", + "httr", + "testthat" + ], + "Encoding": "UTF-8", + "RoxygenNote": "7.1.2", + "NeedsCompilation": "no", + "Author": "Hadley Wickham [aut], Jim Hester [aut], Winston Chang [aut, cre], Kirill Müller [aut], Daniel Cook [aut], Mark Edmondson [ctb]", + "Maintainer": "Winston Chang ", + "Repository": "CRAN" + }, + "mime": { + "Package": "mime", + "Version": "0.13", + "Source": "Repository", + "Type": "Package", + "Title": "Map Filenames to MIME Types", + "Authors@R": "c( person(\"Yihui\", \"Xie\", role = c(\"aut\", \"cre\"), email = \"xie@yihui.name\", comment = c(ORCID = \"0000-0003-0645-5666\", URL = \"https://yihui.org\")), person(\"Jeffrey\", \"Horner\", role = \"ctb\"), person(\"Beilei\", \"Bian\", role = \"ctb\") )", + "Description": "Guesses the MIME type from a filename extension using the data derived from /etc/mime.types in UNIX-type systems.", + "Imports": [ + "tools" + ], + "License": "GPL", + "URL": "https://github.com/yihui/mime", + "BugReports": "https://github.com/yihui/mime/issues", + "RoxygenNote": "7.3.2", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Author": "Yihui Xie [aut, cre] (, https://yihui.org), Jeffrey Horner [ctb], Beilei Bian [ctb]", + "Maintainer": "Yihui Xie ", + "Repository": "CRAN" + }, + "promises": { + "Package": "promises", + "Version": "1.3.3", + "Source": "Repository", + "Type": "Package", + "Title": "Abstractions for Promise-Based Asynchronous Programming", + "Authors@R": "c( person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = c(\"aut\", \"cre\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\"), comment = c(ROR = \"03wc8by49\")) )", + "Description": "Provides fundamental abstractions for doing asynchronous programming in R using promises. Asynchronous programming is useful for allowing a single R process to orchestrate multiple tasks in the background while also attending to something else. Semantics are similar to 'JavaScript' promises, but with a syntax that is idiomatic R.", + "License": "MIT + file LICENSE", + "URL": "https://rstudio.github.io/promises/, https://github.com/rstudio/promises", + "BugReports": "https://github.com/rstudio/promises/issues", + "Imports": [ + "fastmap (>= 1.1.0)", + "later", + "magrittr (>= 1.5)", + "R6", + "Rcpp", + "rlang", + "stats" + ], + "Suggests": [ + "future (>= 1.21.0)", + "knitr", + "purrr", + "rmarkdown", + "spelling", + "testthat (>= 3.0.0)", + "vembedr" + ], + "LinkingTo": [ + "later", + "Rcpp" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "rsconnect, tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/usethis/last-upkeep": "2025-05-27", + "Encoding": "UTF-8", + "Language": "en-US", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "yes", + "Author": "Joe Cheng [aut, cre], Posit Software, PBC [cph, fnd] (ROR: )", + "Maintainer": "Joe Cheng ", + "Repository": "RSPM" + }, + "rappdirs": { + "Package": "rappdirs", + "Version": "0.3.3", + "Source": "Repository", + "Type": "Package", + "Title": "Application Directories: Determine Where to Save Data, Caches, and Logs", + "Authors@R": "c(person(given = \"Hadley\", family = \"Wickham\", role = c(\"trl\", \"cre\", \"cph\"), email = \"hadley@rstudio.com\"), person(given = \"RStudio\", role = \"cph\"), person(given = \"Sridhar\", family = \"Ratnakumar\", role = \"aut\"), person(given = \"Trent\", family = \"Mick\", role = \"aut\"), person(given = \"ActiveState\", role = \"cph\", comment = \"R/appdir.r, R/cache.r, R/data.r, R/log.r translated from appdirs\"), person(given = \"Eddy\", family = \"Petrisor\", role = \"ctb\"), person(given = \"Trevor\", family = \"Davis\", role = c(\"trl\", \"aut\")), person(given = \"Gabor\", family = \"Csardi\", role = \"ctb\"), person(given = \"Gregory\", family = \"Jefferis\", role = \"ctb\"))", + "Description": "An easy way to determine which directories on the users computer you should use to save data, caches and logs. A port of Python's 'Appdirs' () to R.", + "License": "MIT + file LICENSE", + "URL": "https://rappdirs.r-lib.org, https://github.com/r-lib/rappdirs", + "BugReports": "https://github.com/r-lib/rappdirs/issues", + "Depends": [ + "R (>= 3.2)" + ], + "Suggests": [ + "roxygen2", + "testthat (>= 3.0.0)", + "covr", + "withr" + ], + "Copyright": "Original python appdirs module copyright (c) 2010 ActiveState Software Inc. R port copyright Hadley Wickham, RStudio. See file LICENSE for details.", + "Encoding": "UTF-8", + "RoxygenNote": "7.1.1", + "Config/testthat/edition": "3", + "NeedsCompilation": "yes", + "Author": "Hadley Wickham [trl, cre, cph], RStudio [cph], Sridhar Ratnakumar [aut], Trent Mick [aut], ActiveState [cph] (R/appdir.r, R/cache.r, R/data.r, R/log.r translated from appdirs), Eddy Petrisor [ctb], Trevor Davis [trl, aut], Gabor Csardi [ctb], Gregory Jefferis [ctb]", + "Maintainer": "Hadley Wickham ", + "Repository": "CRAN" + }, + "renv": { + "Package": "renv", + "Version": "1.1.5", + "Source": "Repository", + "Type": "Package", + "Title": "Project Environments", + "Authors@R": "c( person(\"Kevin\", \"Ushey\", role = c(\"aut\", \"cre\"), email = \"kevin@rstudio.com\", comment = c(ORCID = \"0000-0003-2880-7407\")), person(\"Hadley\", \"Wickham\", role = c(\"aut\"), email = \"hadley@rstudio.com\", comment = c(ORCID = \"0000-0003-4757-117X\")), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "A dependency management toolkit for R. Using 'renv', you can create and manage project-local R libraries, save the state of these libraries to a 'lockfile', and later restore your library as required. Together, these tools can help make your projects more isolated, portable, and reproducible.", + "License": "MIT + file LICENSE", + "URL": "https://rstudio.github.io/renv/, https://github.com/rstudio/renv", + "BugReports": "https://github.com/rstudio/renv/issues", + "Imports": [ + "utils" + ], + "Suggests": [ + "BiocManager", + "cli", + "compiler", + "covr", + "cpp11", + "devtools", + "generics", + "gitcreds", + "jsonlite", + "jsonvalidate", + "knitr", + "miniUI", + "modules", + "packrat", + "pak", + "R6", + "remotes", + "reticulate", + "rmarkdown", + "rstudioapi", + "shiny", + "testthat", + "uuid", + "waldo", + "yaml", + "webfakes" + ], + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/testthat/parallel": "true", + "Config/testthat/start-first": "bioconductor,python,install,restore,snapshot,retrieve,remotes", + "NeedsCompilation": "no", + "Author": "Kevin Ushey [aut, cre] (ORCID: ), Hadley Wickham [aut] (ORCID: ), Posit Software, PBC [cph, fnd]", + "Maintainer": "Kevin Ushey ", + "Repository": "CRAN" + }, + "rlang": { + "Package": "rlang", + "Version": "1.1.6", + "Source": "Repository", + "Title": "Functions for Base Types and Core R and 'Tidyverse' Features", + "Description": "A toolbox for working with base types, core R features like the condition system, and core 'Tidyverse' features like tidy evaluation.", + "Authors@R": "c( person(\"Lionel\", \"Henry\", ,\"lionel@posit.co\", c(\"aut\", \"cre\")), person(\"Hadley\", \"Wickham\", ,\"hadley@posit.co\", \"aut\"), person(given = \"mikefc\", email = \"mikefc@coolbutuseless.com\", role = \"cph\", comment = \"Hash implementation based on Mike's xxhashlite\"), person(given = \"Yann\", family = \"Collet\", role = \"cph\", comment = \"Author of the embedded xxHash library\"), person(given = \"Posit, PBC\", role = c(\"cph\", \"fnd\")) )", + "License": "MIT + file LICENSE", + "ByteCompile": "true", + "Biarch": "true", + "Depends": [ + "R (>= 3.5.0)" + ], + "Imports": [ + "utils" + ], + "Suggests": [ + "cli (>= 3.1.0)", + "covr", + "crayon", + "desc", + "fs", + "glue", + "knitr", + "magrittr", + "methods", + "pillar", + "pkgload", + "rmarkdown", + "stats", + "testthat (>= 3.2.0)", + "tibble", + "usethis", + "vctrs (>= 0.2.3)", + "withr" + ], + "Enhances": [ + "winch" + ], + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "URL": "https://rlang.r-lib.org, https://github.com/r-lib/rlang", + "BugReports": "https://github.com/r-lib/rlang/issues", + "Config/build/compilation-database": "true", + "Config/testthat/edition": "3", + "Config/Needs/website": "dplyr, tidyverse/tidytemplate", + "NeedsCompilation": "yes", + "Author": "Lionel Henry [aut, cre], Hadley Wickham [aut], mikefc [cph] (Hash implementation based on Mike's xxhashlite), Yann Collet [cph] (Author of the embedded xxHash library), Posit, PBC [cph, fnd]", + "Maintainer": "Lionel Henry ", + "Repository": "CRAN" + }, + "rmarkdown": { + "Package": "rmarkdown", + "Version": "2.30", + "Source": "Repository", + "Type": "Package", + "Title": "Dynamic Documents for R", + "Authors@R": "c( person(\"JJ\", \"Allaire\", , \"jj@posit.co\", role = \"aut\"), person(\"Yihui\", \"Xie\", , \"xie@yihui.name\", role = c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0003-0645-5666\")), person(\"Christophe\", \"Dervieux\", , \"cderv@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0003-4474-2498\")), person(\"Jonathan\", \"McPherson\", , \"jonathan@posit.co\", role = \"aut\"), person(\"Javier\", \"Luraschi\", role = \"aut\"), person(\"Kevin\", \"Ushey\", , \"kevin@posit.co\", role = \"aut\"), person(\"Aron\", \"Atkins\", , \"aron@posit.co\", role = \"aut\"), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Joe\", \"Cheng\", , \"joe@posit.co\", role = \"aut\"), person(\"Winston\", \"Chang\", , \"winston@posit.co\", role = \"aut\"), person(\"Richard\", \"Iannone\", , \"rich@posit.co\", role = \"aut\", comment = c(ORCID = \"0000-0003-3925-190X\")), person(\"Andrew\", \"Dunning\", role = \"ctb\", comment = c(ORCID = \"0000-0003-0464-5036\")), person(\"Atsushi\", \"Yasumoto\", role = c(\"ctb\", \"cph\"), comment = c(ORCID = \"0000-0002-8335-495X\", cph = \"Number sections Lua filter\")), person(\"Barret\", \"Schloerke\", role = \"ctb\"), person(\"Carson\", \"Sievert\", role = \"ctb\", comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Devon\", \"Ryan\", , \"dpryan79@gmail.com\", role = \"ctb\", comment = c(ORCID = \"0000-0002-8549-0971\")), person(\"Frederik\", \"Aust\", , \"frederik.aust@uni-koeln.de\", role = \"ctb\", comment = c(ORCID = \"0000-0003-4900-788X\")), person(\"Jeff\", \"Allen\", , \"jeff@posit.co\", role = \"ctb\"), person(\"JooYoung\", \"Seo\", role = \"ctb\", comment = c(ORCID = \"0000-0002-4064-6012\")), person(\"Malcolm\", \"Barrett\", role = \"ctb\"), person(\"Rob\", \"Hyndman\", , \"Rob.Hyndman@monash.edu\", role = \"ctb\"), person(\"Romain\", \"Lesur\", role = \"ctb\"), person(\"Roy\", \"Storey\", role = \"ctb\"), person(\"Ruben\", \"Arslan\", , \"ruben.arslan@uni-goettingen.de\", role = \"ctb\"), person(\"Sergio\", \"Oller\", role = \"ctb\"), person(given = \"Posit Software, PBC\", role = c(\"cph\", \"fnd\")), person(, \"jQuery UI contributors\", role = c(\"ctb\", \"cph\"), comment = \"jQuery UI library; authors listed in inst/rmd/h/jqueryui/AUTHORS.txt\"), person(\"Mark\", \"Otto\", role = \"ctb\", comment = \"Bootstrap library\"), person(\"Jacob\", \"Thornton\", role = \"ctb\", comment = \"Bootstrap library\"), person(, \"Bootstrap contributors\", role = \"ctb\", comment = \"Bootstrap library\"), person(, \"Twitter, Inc\", role = \"cph\", comment = \"Bootstrap library\"), person(\"Alexander\", \"Farkas\", role = c(\"ctb\", \"cph\"), comment = \"html5shiv library\"), person(\"Scott\", \"Jehl\", role = c(\"ctb\", \"cph\"), comment = \"Respond.js library\"), person(\"Ivan\", \"Sagalaev\", role = c(\"ctb\", \"cph\"), comment = \"highlight.js library\"), person(\"Greg\", \"Franko\", role = c(\"ctb\", \"cph\"), comment = \"tocify library\"), person(\"John\", \"MacFarlane\", role = c(\"ctb\", \"cph\"), comment = \"Pandoc templates\"), person(, \"Google, Inc.\", role = c(\"ctb\", \"cph\"), comment = \"ioslides library\"), person(\"Dave\", \"Raggett\", role = \"ctb\", comment = \"slidy library\"), person(, \"W3C\", role = \"cph\", comment = \"slidy library\"), person(\"Dave\", \"Gandy\", role = c(\"ctb\", \"cph\"), comment = \"Font-Awesome\"), person(\"Ben\", \"Sperry\", role = \"ctb\", comment = \"Ionicons\"), person(, \"Drifty\", role = \"cph\", comment = \"Ionicons\"), person(\"Aidan\", \"Lister\", role = c(\"ctb\", \"cph\"), comment = \"jQuery StickyTabs\"), person(\"Benct Philip\", \"Jonsson\", role = c(\"ctb\", \"cph\"), comment = \"pagebreak Lua filter\"), person(\"Albert\", \"Krewinkel\", role = c(\"ctb\", \"cph\"), comment = \"pagebreak Lua filter\") )", + "Description": "Convert R Markdown documents into a variety of formats.", + "License": "GPL-3", + "URL": "https://github.com/rstudio/rmarkdown, https://pkgs.rstudio.com/rmarkdown/", + "BugReports": "https://github.com/rstudio/rmarkdown/issues", + "Depends": [ + "R (>= 3.0)" + ], + "Imports": [ + "bslib (>= 0.2.5.1)", + "evaluate (>= 0.13)", + "fontawesome (>= 0.5.0)", + "htmltools (>= 0.5.1)", + "jquerylib", + "jsonlite", + "knitr (>= 1.43)", + "methods", + "tinytex (>= 0.31)", + "tools", + "utils", + "xfun (>= 0.36)", + "yaml (>= 2.1.19)" + ], + "Suggests": [ + "digest", + "dygraphs", + "fs", + "rsconnect", + "downlit (>= 0.4.0)", + "katex (>= 1.4.0)", + "sass (>= 0.4.0)", + "shiny (>= 1.6.0)", + "testthat (>= 3.0.3)", + "tibble", + "vctrs", + "cleanrmd", + "withr (>= 2.4.2)", + "xml2" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "rstudio/quillt, pkgdown", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "SystemRequirements": "pandoc (>= 1.14) - http://pandoc.org", + "NeedsCompilation": "no", + "Author": "JJ Allaire [aut], Yihui Xie [aut, cre] (ORCID: ), Christophe Dervieux [aut] (ORCID: ), Jonathan McPherson [aut], Javier Luraschi [aut], Kevin Ushey [aut], Aron Atkins [aut], Hadley Wickham [aut], Joe Cheng [aut], Winston Chang [aut], Richard Iannone [aut] (ORCID: ), Andrew Dunning [ctb] (ORCID: ), Atsushi Yasumoto [ctb, cph] (ORCID: , cph: Number sections Lua filter), Barret Schloerke [ctb], Carson Sievert [ctb] (ORCID: ), Devon Ryan [ctb] (ORCID: ), Frederik Aust [ctb] (ORCID: ), Jeff Allen [ctb], JooYoung Seo [ctb] (ORCID: ), Malcolm Barrett [ctb], Rob Hyndman [ctb], Romain Lesur [ctb], Roy Storey [ctb], Ruben Arslan [ctb], Sergio Oller [ctb], Posit Software, PBC [cph, fnd], jQuery UI contributors [ctb, cph] (jQuery UI library; authors listed in inst/rmd/h/jqueryui/AUTHORS.txt), Mark Otto [ctb] (Bootstrap library), Jacob Thornton [ctb] (Bootstrap library), Bootstrap contributors [ctb] (Bootstrap library), Twitter, Inc [cph] (Bootstrap library), Alexander Farkas [ctb, cph] (html5shiv library), Scott Jehl [ctb, cph] (Respond.js library), Ivan Sagalaev [ctb, cph] (highlight.js library), Greg Franko [ctb, cph] (tocify library), John MacFarlane [ctb, cph] (Pandoc templates), Google, Inc. [ctb, cph] (ioslides library), Dave Raggett [ctb] (slidy library), W3C [cph] (slidy library), Dave Gandy [ctb, cph] (Font-Awesome), Ben Sperry [ctb] (Ionicons), Drifty [cph] (Ionicons), Aidan Lister [ctb, cph] (jQuery StickyTabs), Benct Philip Jonsson [ctb, cph] (pagebreak Lua filter), Albert Krewinkel [ctb, cph] (pagebreak Lua filter)", + "Maintainer": "Yihui Xie ", + "Repository": "CRAN" + }, + "sass": { + "Package": "sass", + "Version": "0.4.10", + "Source": "Repository", + "Type": "Package", + "Title": "Syntactically Awesome Style Sheets ('Sass')", + "Description": "An 'SCSS' compiler, powered by the 'LibSass' library. With this, R developers can use variables, inheritance, and functions to generate dynamic style sheets. The package uses the 'Sass CSS' extension language, which is stable, powerful, and CSS compatible.", + "Authors@R": "c( person(\"Joe\", \"Cheng\", , \"joe@rstudio.com\", \"aut\"), person(\"Timothy\", \"Mastny\", , \"tim.mastny@gmail.com\", \"aut\"), person(\"Richard\", \"Iannone\", , \"rich@rstudio.com\", \"aut\", comment = c(ORCID = \"0000-0003-3925-190X\")), person(\"Barret\", \"Schloerke\", , \"barret@rstudio.com\", \"aut\", comment = c(ORCID = \"0000-0001-9986-114X\")), person(\"Carson\", \"Sievert\", , \"carson@rstudio.com\", c(\"aut\", \"cre\"), comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Christophe\", \"Dervieux\", , \"cderv@rstudio.com\", c(\"ctb\"), comment = c(ORCID = \"0000-0003-4474-2498\")), person(family = \"RStudio\", role = c(\"cph\", \"fnd\")), person(family = \"Sass Open Source Foundation\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Greter\", \"Marcel\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Mifsud\", \"Michael\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Hampton\", \"Catlin\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Natalie\", \"Weizenbaum\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Chris\", \"Eppstein\", role = c(\"ctb\", \"cph\"), comment = \"LibSass library\"), person(\"Adams\", \"Joseph\", role = c(\"ctb\", \"cph\"), comment = \"json.cpp\"), person(\"Trifunovic\", \"Nemanja\", role = c(\"ctb\", \"cph\"), comment = \"utf8.h\") )", + "License": "MIT + file LICENSE", + "URL": "https://rstudio.github.io/sass/, https://github.com/rstudio/sass", + "BugReports": "https://github.com/rstudio/sass/issues", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "SystemRequirements": "GNU make", + "Imports": [ + "fs (>= 1.2.4)", + "rlang (>= 0.4.10)", + "htmltools (>= 0.5.1)", + "R6", + "rappdirs" + ], + "Suggests": [ + "testthat", + "knitr", + "rmarkdown", + "withr", + "shiny", + "curl" + ], + "VignetteBuilder": "knitr", + "Config/testthat/edition": "3", + "NeedsCompilation": "yes", + "Author": "Joe Cheng [aut], Timothy Mastny [aut], Richard Iannone [aut] (), Barret Schloerke [aut] (), Carson Sievert [aut, cre] (), Christophe Dervieux [ctb] (), RStudio [cph, fnd], Sass Open Source Foundation [ctb, cph] (LibSass library), Greter Marcel [ctb, cph] (LibSass library), Mifsud Michael [ctb, cph] (LibSass library), Hampton Catlin [ctb, cph] (LibSass library), Natalie Weizenbaum [ctb, cph] (LibSass library), Chris Eppstein [ctb, cph] (LibSass library), Adams Joseph [ctb, cph] (json.cpp), Trifunovic Nemanja [ctb, cph] (utf8.h)", + "Maintainer": "Carson Sievert ", + "Repository": "CRAN" + }, + "scales": { + "Package": "scales", + "Version": "1.4.0", + "Source": "Repository", + "Title": "Scale Functions for Visualization", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Thomas Lin\", \"Pedersen\", , \"thomas.pedersen@posit.co\", role = c(\"cre\", \"aut\"), comment = c(ORCID = \"0000-0002-5147-4711\")), person(\"Dana\", \"Seidel\", role = \"aut\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\"), comment = c(ROR = \"03wc8by49\")) )", + "Description": "Graphical scales map data to aesthetics, and provide methods for automatically determining breaks and labels for axes and legends.", + "License": "MIT + file LICENSE", + "URL": "https://scales.r-lib.org, https://github.com/r-lib/scales", + "BugReports": "https://github.com/r-lib/scales/issues", + "Depends": [ + "R (>= 4.1)" + ], + "Imports": [ + "cli", + "farver (>= 2.0.3)", + "glue", + "labeling", + "lifecycle", + "R6", + "RColorBrewer", + "rlang (>= 1.1.0)", + "viridisLite" + ], + "Suggests": [ + "bit64", + "covr", + "dichromat", + "ggplot2", + "hms (>= 0.5.0)", + "stringi", + "testthat (>= 3.0.0)" + ], + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Config/usethis/last-upkeep": "2025-04-23", + "Encoding": "UTF-8", + "LazyLoad": "yes", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Hadley Wickham [aut], Thomas Lin Pedersen [cre, aut] (), Dana Seidel [aut], Posit Software, PBC [cph, fnd] (03wc8by49)", + "Maintainer": "Thomas Lin Pedersen ", + "Repository": "RSPM" + }, + "shiny": { + "Package": "shiny", + "Version": "1.11.1", + "Source": "Repository", + "Type": "Package", + "Title": "Web Application Framework for R", + "Authors@R": "c( person(\"Winston\", \"Chang\", role = c(\"aut\", \"cre\"), email = \"winston@posit.co\", comment = c(ORCID = \"0000-0002-1576-2126\")), person(\"Joe\", \"Cheng\", role = \"aut\", email = \"joe@posit.co\"), person(\"JJ\", \"Allaire\", role = \"aut\", email = \"jj@posit.co\"), person(\"Carson\", \"Sievert\", role = \"aut\", email = \"carson@posit.co\", comment = c(ORCID = \"0000-0002-4958-2844\")), person(\"Barret\", \"Schloerke\", role = \"aut\", email = \"barret@posit.co\", comment = c(ORCID = \"0000-0001-9986-114X\")), person(\"Yihui\", \"Xie\", role = \"aut\", email = \"yihui@posit.co\"), person(\"Jeff\", \"Allen\", role = \"aut\"), person(\"Jonathan\", \"McPherson\", role = \"aut\", email = \"jonathan@posit.co\"), person(\"Alan\", \"Dipert\", role = \"aut\"), person(\"Barbara\", \"Borges\", role = \"aut\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")), person(family = \"jQuery Foundation\", role = \"cph\", comment = \"jQuery library and jQuery UI library\"), person(family = \"jQuery contributors\", role = c(\"ctb\", \"cph\"), comment = \"jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt\"), person(family = \"jQuery UI contributors\", role = c(\"ctb\", \"cph\"), comment = \"jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt\"), person(\"Mark\", \"Otto\", role = \"ctb\", comment = \"Bootstrap library\"), person(\"Jacob\", \"Thornton\", role = \"ctb\", comment = \"Bootstrap library\"), person(family = \"Bootstrap contributors\", role = \"ctb\", comment = \"Bootstrap library\"), person(family = \"Twitter, Inc\", role = \"cph\", comment = \"Bootstrap library\"), person(\"Prem Nawaz\", \"Khan\", role = \"ctb\", comment = \"Bootstrap accessibility plugin\"), person(\"Victor\", \"Tsaran\", role = \"ctb\", comment = \"Bootstrap accessibility plugin\"), person(\"Dennis\", \"Lembree\", role = \"ctb\", comment = \"Bootstrap accessibility plugin\"), person(\"Srinivasu\", \"Chakravarthula\", role = \"ctb\", comment = \"Bootstrap accessibility plugin\"), person(\"Cathy\", \"O'Connor\", role = \"ctb\", comment = \"Bootstrap accessibility plugin\"), person(family = \"PayPal, Inc\", role = \"cph\", comment = \"Bootstrap accessibility plugin\"), person(\"Stefan\", \"Petre\", role = c(\"ctb\", \"cph\"), comment = \"Bootstrap-datepicker library\"), person(\"Andrew\", \"Rowls\", role = c(\"ctb\", \"cph\"), comment = \"Bootstrap-datepicker library\"), person(\"Brian\", \"Reavis\", role = c(\"ctb\", \"cph\"), comment = \"selectize.js library\"), person(\"Salmen\", \"Bejaoui\", role = c(\"ctb\", \"cph\"), comment = \"selectize-plugin-a11y library\"), person(\"Denis\", \"Ineshin\", role = c(\"ctb\", \"cph\"), comment = \"ion.rangeSlider library\"), person(\"Sami\", \"Samhuri\", role = c(\"ctb\", \"cph\"), comment = \"Javascript strftime library\"), person(family = \"SpryMedia Limited\", role = c(\"ctb\", \"cph\"), comment = \"DataTables library\"), person(\"John\", \"Fraser\", role = c(\"ctb\", \"cph\"), comment = \"showdown.js library\"), person(\"John\", \"Gruber\", role = c(\"ctb\", \"cph\"), comment = \"showdown.js library\"), person(\"Ivan\", \"Sagalaev\", role = c(\"ctb\", \"cph\"), comment = \"highlight.js library\"), person(given = \"R Core Team\", role = c(\"ctb\", \"cph\"), comment = \"tar implementation from R\") )", + "Description": "Makes it incredibly easy to build interactive web applications with R. Automatic \"reactive\" binding between inputs and outputs and extensive prebuilt widgets make it possible to build beautiful, responsive, and powerful applications with minimal effort.", + "License": "GPL-3 | file LICENSE", + "Depends": [ + "R (>= 3.0.2)", + "methods" + ], + "Imports": [ + "utils", + "grDevices", + "httpuv (>= 1.5.2)", + "mime (>= 0.3)", + "jsonlite (>= 0.9.16)", + "xtable", + "fontawesome (>= 0.4.0)", + "htmltools (>= 0.5.4)", + "R6 (>= 2.0)", + "sourcetools", + "later (>= 1.0.0)", + "promises (>= 1.3.2)", + "tools", + "cli", + "rlang (>= 0.4.10)", + "fastmap (>= 1.1.1)", + "withr", + "commonmark (>= 1.7)", + "glue (>= 1.3.2)", + "bslib (>= 0.6.0)", + "cachem (>= 1.1.0)", + "lifecycle (>= 0.2.0)" + ], + "Suggests": [ + "coro (>= 1.1.0)", + "datasets", + "DT", + "Cairo (>= 1.5-5)", + "testthat (>= 3.2.1)", + "knitr (>= 1.6)", + "markdown", + "rmarkdown", + "ggplot2", + "reactlog (>= 1.0.0)", + "magrittr", + "yaml", + "mirai", + "future", + "dygraphs", + "ragg", + "showtext", + "sass", + "watcher" + ], + "URL": "https://shiny.posit.co/, https://github.com/rstudio/shiny", + "BugReports": "https://github.com/rstudio/shiny/issues", + "Collate": "'globals.R' 'app-state.R' 'app_template.R' 'bind-cache.R' 'bind-event.R' 'bookmark-state-local.R' 'bookmark-state.R' 'bootstrap-deprecated.R' 'bootstrap-layout.R' 'conditions.R' 'map.R' 'utils.R' 'bootstrap.R' 'busy-indicators-spinners.R' 'busy-indicators.R' 'cache-utils.R' 'deprecated.R' 'devmode.R' 'diagnose.R' 'extended-task.R' 'fileupload.R' 'graph.R' 'reactives.R' 'reactive-domains.R' 'history.R' 'hooks.R' 'html-deps.R' 'image-interact-opts.R' 'image-interact.R' 'imageutils.R' 'input-action.R' 'input-checkbox.R' 'input-checkboxgroup.R' 'input-date.R' 'input-daterange.R' 'input-file.R' 'input-numeric.R' 'input-password.R' 'input-radiobuttons.R' 'input-select.R' 'input-slider.R' 'input-submit.R' 'input-text.R' 'input-textarea.R' 'input-utils.R' 'insert-tab.R' 'insert-ui.R' 'jqueryui.R' 'knitr.R' 'middleware-shiny.R' 'middleware.R' 'timer.R' 'shiny.R' 'mock-session.R' 'modal.R' 'modules.R' 'notifications.R' 'priorityqueue.R' 'progress.R' 'react.R' 'reexports.R' 'render-cached-plot.R' 'render-plot.R' 'render-table.R' 'run-url.R' 'runapp.R' 'serializers.R' 'server-input-handlers.R' 'server-resource-paths.R' 'server.R' 'shiny-options.R' 'shiny-package.R' 'shinyapp.R' 'shinyui.R' 'shinywrappers.R' 'showcase.R' 'snapshot.R' 'staticimports.R' 'tar.R' 'test-export.R' 'test-server.R' 'test.R' 'update-input.R' 'utils-lang.R' 'version_bs_date_picker.R' 'version_ion_range_slider.R' 'version_jquery.R' 'version_jqueryui.R' 'version_selectize.R' 'version_strftime.R' 'viewer.R'", + "RoxygenNote": "7.3.2", + "Encoding": "UTF-8", + "Config/testthat/edition": "3", + "Config/Needs/check": "shinytest2", + "NeedsCompilation": "no", + "Author": "Winston Chang [aut, cre] (ORCID: ), Joe Cheng [aut], JJ Allaire [aut], Carson Sievert [aut] (ORCID: ), Barret Schloerke [aut] (ORCID: ), Yihui Xie [aut], Jeff Allen [aut], Jonathan McPherson [aut], Alan Dipert [aut], Barbara Borges [aut], Posit Software, PBC [cph, fnd], jQuery Foundation [cph] (jQuery library and jQuery UI library), jQuery contributors [ctb, cph] (jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt), jQuery UI contributors [ctb, cph] (jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt), Mark Otto [ctb] (Bootstrap library), Jacob Thornton [ctb] (Bootstrap library), Bootstrap contributors [ctb] (Bootstrap library), Twitter, Inc [cph] (Bootstrap library), Prem Nawaz Khan [ctb] (Bootstrap accessibility plugin), Victor Tsaran [ctb] (Bootstrap accessibility plugin), Dennis Lembree [ctb] (Bootstrap accessibility plugin), Srinivasu Chakravarthula [ctb] (Bootstrap accessibility plugin), Cathy O'Connor [ctb] (Bootstrap accessibility plugin), PayPal, Inc [cph] (Bootstrap accessibility plugin), Stefan Petre [ctb, cph] (Bootstrap-datepicker library), Andrew Rowls [ctb, cph] (Bootstrap-datepicker library), Brian Reavis [ctb, cph] (selectize.js library), Salmen Bejaoui [ctb, cph] (selectize-plugin-a11y library), Denis Ineshin [ctb, cph] (ion.rangeSlider library), Sami Samhuri [ctb, cph] (Javascript strftime library), SpryMedia Limited [ctb, cph] (DataTables library), John Fraser [ctb, cph] (showdown.js library), John Gruber [ctb, cph] (showdown.js library), Ivan Sagalaev [ctb, cph] (highlight.js library), R Core Team [ctb, cph] (tar implementation from R)", + "Maintainer": "Winston Chang ", + "Repository": "RSPM" + }, + "sourcetools": { + "Package": "sourcetools", + "Version": "0.1.7-1", + "Source": "Repository", + "Type": "Package", + "Title": "Tools for Reading, Tokenizing and Parsing R Code", + "Author": "Kevin Ushey", + "Maintainer": "Kevin Ushey ", + "Description": "Tools for the reading and tokenization of R code. The 'sourcetools' package provides both an R and C++ interface for the tokenization of R code, and helpers for interacting with the tokenized representation of R code.", + "License": "MIT + file LICENSE", + "Depends": [ + "R (>= 3.0.2)" + ], + "Suggests": [ + "testthat" + ], + "RoxygenNote": "5.0.1", + "BugReports": "https://github.com/kevinushey/sourcetools/issues", + "Encoding": "UTF-8", + "NeedsCompilation": "yes", + "Repository": "RSPM" + }, + "tinytex": { + "Package": "tinytex", + "Version": "0.57", + "Source": "Repository", + "Type": "Package", + "Title": "Helper Functions to Install and Maintain TeX Live, and Compile LaTeX Documents", + "Authors@R": "c( person(\"Yihui\", \"Xie\", role = c(\"aut\", \"cre\", \"cph\"), email = \"xie@yihui.name\", comment = c(ORCID = \"0000-0003-0645-5666\")), person(given = \"Posit Software, PBC\", role = c(\"cph\", \"fnd\")), person(\"Christophe\", \"Dervieux\", role = \"ctb\", comment = c(ORCID = \"0000-0003-4474-2498\")), person(\"Devon\", \"Ryan\", role = \"ctb\", email = \"dpryan79@gmail.com\", comment = c(ORCID = \"0000-0002-8549-0971\")), person(\"Ethan\", \"Heinzen\", role = \"ctb\"), person(\"Fernando\", \"Cagua\", role = \"ctb\"), person() )", + "Description": "Helper functions to install and maintain the 'LaTeX' distribution named 'TinyTeX' (), a lightweight, cross-platform, portable, and easy-to-maintain version of 'TeX Live'. This package also contains helper functions to compile 'LaTeX' documents, and install missing 'LaTeX' packages automatically.", + "Imports": [ + "xfun (>= 0.48)" + ], + "Suggests": [ + "testit", + "rstudioapi" + ], + "License": "MIT + file LICENSE", + "URL": "https://github.com/rstudio/tinytex", + "BugReports": "https://github.com/rstudio/tinytex/issues", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "NeedsCompilation": "no", + "Author": "Yihui Xie [aut, cre, cph] (), Posit Software, PBC [cph, fnd], Christophe Dervieux [ctb] (), Devon Ryan [ctb] (), Ethan Heinzen [ctb], Fernando Cagua [ctb]", + "Maintainer": "Yihui Xie ", + "Repository": "RSPM" + }, + "vctrs": { + "Package": "vctrs", + "Version": "0.6.5", + "Source": "Repository", + "Title": "Vector Helpers", + "Authors@R": "c( person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Lionel\", \"Henry\", , \"lionel@posit.co\", role = \"aut\"), person(\"Davis\", \"Vaughan\", , \"davis@posit.co\", role = c(\"aut\", \"cre\")), person(\"data.table team\", role = \"cph\", comment = \"Radix sort based on data.table's forder() and their contribution to R's order()\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "Defines new notions of prototype and size that are used to provide tools for consistent and well-founded type-coercion and size-recycling, and are in turn connected to ideas of type- and size-stability useful for analysing function interfaces.", + "License": "MIT + file LICENSE", + "URL": "https://vctrs.r-lib.org/, https://github.com/r-lib/vctrs", + "BugReports": "https://github.com/r-lib/vctrs/issues", + "Depends": [ + "R (>= 3.5.0)" + ], + "Imports": [ + "cli (>= 3.4.0)", + "glue", + "lifecycle (>= 1.0.3)", + "rlang (>= 1.1.0)" + ], + "Suggests": [ + "bit64", + "covr", + "crayon", + "dplyr (>= 0.8.5)", + "generics", + "knitr", + "pillar (>= 1.4.4)", + "pkgdown (>= 2.0.1)", + "rmarkdown", + "testthat (>= 3.0.0)", + "tibble (>= 3.1.3)", + "waldo (>= 0.2.0)", + "withr", + "xml2", + "zeallot" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "Language": "en-GB", + "RoxygenNote": "7.2.3", + "NeedsCompilation": "yes", + "Author": "Hadley Wickham [aut], Lionel Henry [aut], Davis Vaughan [aut, cre], data.table team [cph] (Radix sort based on data.table's forder() and their contribution to R's order()), Posit Software, PBC [cph, fnd]", + "Maintainer": "Davis Vaughan ", + "Repository": "CRAN" + }, + "viridisLite": { + "Package": "viridisLite", + "Version": "0.4.2", + "Source": "Repository", + "Type": "Package", + "Title": "Colorblind-Friendly Color Maps (Lite Version)", + "Date": "2023-05-02", + "Authors@R": "c( person(\"Simon\", \"Garnier\", email = \"garnier@njit.edu\", role = c(\"aut\", \"cre\")), person(\"Noam\", \"Ross\", email = \"noam.ross@gmail.com\", role = c(\"ctb\", \"cph\")), person(\"Bob\", \"Rudis\", email = \"bob@rud.is\", role = c(\"ctb\", \"cph\")), person(\"Marco\", \"Sciaini\", email = \"sciaini.marco@gmail.com\", role = c(\"ctb\", \"cph\")), person(\"Antônio Pedro\", \"Camargo\", role = c(\"ctb\", \"cph\")), person(\"Cédric\", \"Scherer\", email = \"scherer@izw-berlin.de\", role = c(\"ctb\", \"cph\")) )", + "Maintainer": "Simon Garnier ", + "Description": "Color maps designed to improve graph readability for readers with common forms of color blindness and/or color vision deficiency. The color maps are also perceptually-uniform, both in regular form and also when converted to black-and-white for printing. This is the 'lite' version of the 'viridis' package that also contains 'ggplot2' bindings for discrete and continuous color and fill scales and can be found at .", + "License": "MIT + file LICENSE", + "Encoding": "UTF-8", + "Depends": [ + "R (>= 2.10)" + ], + "Suggests": [ + "hexbin (>= 1.27.0)", + "ggplot2 (>= 1.0.1)", + "testthat", + "covr" + ], + "URL": "https://sjmgarnier.github.io/viridisLite/, https://github.com/sjmgarnier/viridisLite/", + "BugReports": "https://github.com/sjmgarnier/viridisLite/issues/", + "RoxygenNote": "7.2.3", + "NeedsCompilation": "no", + "Author": "Simon Garnier [aut, cre], Noam Ross [ctb, cph], Bob Rudis [ctb, cph], Marco Sciaini [ctb, cph], Antônio Pedro Camargo [ctb, cph], Cédric Scherer [ctb, cph]", + "Repository": "CRAN" + }, + "withr": { + "Package": "withr", + "Version": "3.0.2", + "Source": "Repository", + "Title": "Run Code 'With' Temporarily Modified Global State", + "Authors@R": "c( person(\"Jim\", \"Hester\", role = \"aut\"), person(\"Lionel\", \"Henry\", , \"lionel@posit.co\", role = c(\"aut\", \"cre\")), person(\"Kirill\", \"Müller\", , \"krlmlr+r@mailbox.org\", role = \"aut\"), person(\"Kevin\", \"Ushey\", , \"kevinushey@gmail.com\", role = \"aut\"), person(\"Hadley\", \"Wickham\", , \"hadley@posit.co\", role = \"aut\"), person(\"Winston\", \"Chang\", role = \"aut\"), person(\"Jennifer\", \"Bryan\", role = \"ctb\"), person(\"Richard\", \"Cotton\", role = \"ctb\"), person(\"Posit Software, PBC\", role = c(\"cph\", \"fnd\")) )", + "Description": "A set of functions to run code 'with' safely and temporarily modified global state. Many of these functions were originally a part of the 'devtools' package, this provides a simple package with limited dependencies to provide access to these functions.", + "License": "MIT + file LICENSE", + "URL": "https://withr.r-lib.org, https://github.com/r-lib/withr#readme", + "BugReports": "https://github.com/r-lib/withr/issues", + "Depends": [ + "R (>= 3.6.0)" + ], + "Imports": [ + "graphics", + "grDevices" + ], + "Suggests": [ + "callr", + "DBI", + "knitr", + "methods", + "rlang", + "rmarkdown (>= 2.12)", + "RSQLite", + "testthat (>= 3.0.0)" + ], + "VignetteBuilder": "knitr", + "Config/Needs/website": "tidyverse/tidytemplate", + "Config/testthat/edition": "3", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "Collate": "'aaa.R' 'collate.R' 'connection.R' 'db.R' 'defer-exit.R' 'standalone-defer.R' 'defer.R' 'devices.R' 'local_.R' 'with_.R' 'dir.R' 'env.R' 'file.R' 'language.R' 'libpaths.R' 'locale.R' 'makevars.R' 'namespace.R' 'options.R' 'par.R' 'path.R' 'rng.R' 'seed.R' 'wrap.R' 'sink.R' 'tempfile.R' 'timezone.R' 'torture.R' 'utils.R' 'with.R'", + "NeedsCompilation": "no", + "Author": "Jim Hester [aut], Lionel Henry [aut, cre], Kirill Müller [aut], Kevin Ushey [aut], Hadley Wickham [aut], Winston Chang [aut], Jennifer Bryan [ctb], Richard Cotton [ctb], Posit Software, PBC [cph, fnd]", + "Maintainer": "Lionel Henry ", + "Repository": "CRAN" + }, + "xfun": { + "Package": "xfun", + "Version": "0.53", + "Source": "Repository", + "Type": "Package", + "Title": "Supporting Functions for Packages Maintained by 'Yihui Xie'", + "Authors@R": "c( person(\"Yihui\", \"Xie\", role = c(\"aut\", \"cre\", \"cph\"), email = \"xie@yihui.name\", comment = c(ORCID = \"0000-0003-0645-5666\", URL = \"https://yihui.org\")), person(\"Wush\", \"Wu\", role = \"ctb\"), person(\"Daijiang\", \"Li\", role = \"ctb\"), person(\"Xianying\", \"Tan\", role = \"ctb\"), person(\"Salim\", \"Brüggemann\", role = \"ctb\", email = \"salim-b@pm.me\", comment = c(ORCID = \"0000-0002-5329-5987\")), person(\"Christophe\", \"Dervieux\", role = \"ctb\"), person() )", + "Description": "Miscellaneous functions commonly used in other packages maintained by 'Yihui Xie'.", + "Depends": [ + "R (>= 3.2.0)" + ], + "Imports": [ + "grDevices", + "stats", + "tools" + ], + "Suggests": [ + "testit", + "parallel", + "codetools", + "methods", + "rstudioapi", + "tinytex (>= 0.30)", + "mime", + "litedown (>= 0.6)", + "commonmark", + "knitr (>= 1.50)", + "remotes", + "pak", + "curl", + "xml2", + "jsonlite", + "magick", + "yaml", + "data.table", + "qs" + ], + "License": "MIT + file LICENSE", + "URL": "https://github.com/yihui/xfun", + "BugReports": "https://github.com/yihui/xfun/issues", + "Encoding": "UTF-8", + "RoxygenNote": "7.3.2", + "VignetteBuilder": "litedown", + "NeedsCompilation": "yes", + "Author": "Yihui Xie [aut, cre, cph] (ORCID: , URL: https://yihui.org), Wush Wu [ctb], Daijiang Li [ctb], Xianying Tan [ctb], Salim Brüggemann [ctb] (ORCID: ), Christophe Dervieux [ctb]", + "Maintainer": "Yihui Xie ", + "Repository": "CRAN" + }, + "xtable": { + "Package": "xtable", + "Version": "1.8-4", + "Source": "Repository", + "Date": "2019-04-08", + "Title": "Export Tables to LaTeX or HTML", + "Authors@R": "c(person(\"David B.\", \"Dahl\", role=\"aut\"), person(\"David\", \"Scott\", role=c(\"aut\",\"cre\"), email=\"d.scott@auckland.ac.nz\"), person(\"Charles\", \"Roosen\", role=\"aut\"), person(\"Arni\", \"Magnusson\", role=\"aut\"), person(\"Jonathan\", \"Swinton\", role=\"aut\"), person(\"Ajay\", \"Shah\", role=\"ctb\"), person(\"Arne\", \"Henningsen\", role=\"ctb\"), person(\"Benno\", \"Puetz\", role=\"ctb\"), person(\"Bernhard\", \"Pfaff\", role=\"ctb\"), person(\"Claudio\", \"Agostinelli\", role=\"ctb\"), person(\"Claudius\", \"Loehnert\", role=\"ctb\"), person(\"David\", \"Mitchell\", role=\"ctb\"), person(\"David\", \"Whiting\", role=\"ctb\"), person(\"Fernando da\", \"Rosa\", role=\"ctb\"), person(\"Guido\", \"Gay\", role=\"ctb\"), person(\"Guido\", \"Schulz\", role=\"ctb\"), person(\"Ian\", \"Fellows\", role=\"ctb\"), person(\"Jeff\", \"Laake\", role=\"ctb\"), person(\"John\", \"Walker\", role=\"ctb\"), person(\"Jun\", \"Yan\", role=\"ctb\"), person(\"Liviu\", \"Andronic\", role=\"ctb\"), person(\"Markus\", \"Loecher\", role=\"ctb\"), person(\"Martin\", \"Gubri\", role=\"ctb\"), person(\"Matthieu\", \"Stigler\", role=\"ctb\"), person(\"Robert\", \"Castelo\", role=\"ctb\"), person(\"Seth\", \"Falcon\", role=\"ctb\"), person(\"Stefan\", \"Edwards\", role=\"ctb\"), person(\"Sven\", \"Garbade\", role=\"ctb\"), person(\"Uwe\", \"Ligges\", role=\"ctb\"))", + "Maintainer": "David Scott ", + "Imports": [ + "stats", + "utils" + ], + "Suggests": [ + "knitr", + "plm", + "zoo", + "survival" + ], + "VignetteBuilder": "knitr", + "Description": "Coerce data to LaTeX and HTML tables.", + "URL": "http://xtable.r-forge.r-project.org/", + "Depends": [ + "R (>= 2.10.0)" + ], + "License": "GPL (>= 2)", + "Repository": "CRAN", + "NeedsCompilation": "no", + "Author": "David B. Dahl [aut], David Scott [aut, cre], Charles Roosen [aut], Arni Magnusson [aut], Jonathan Swinton [aut], Ajay Shah [ctb], Arne Henningsen [ctb], Benno Puetz [ctb], Bernhard Pfaff [ctb], Claudio Agostinelli [ctb], Claudius Loehnert [ctb], David Mitchell [ctb], David Whiting [ctb], Fernando da Rosa [ctb], Guido Gay [ctb], Guido Schulz [ctb], Ian Fellows [ctb], Jeff Laake [ctb], John Walker [ctb], Jun Yan [ctb], Liviu Andronic [ctb], Markus Loecher [ctb], Martin Gubri [ctb], Matthieu Stigler [ctb], Robert Castelo [ctb], Seth Falcon [ctb], Stefan Edwards [ctb], Sven Garbade [ctb], Uwe Ligges [ctb]" + }, + "yaml": { + "Package": "yaml", + "Version": "2.3.10", + "Source": "Repository", + "Type": "Package", + "Title": "Methods to Convert R Data to YAML and Back", + "Date": "2024-07-22", + "Suggests": [ + "RUnit" + ], + "Author": "Shawn P Garbett [aut], Jeremy Stephens [aut, cre], Kirill Simonov [aut], Yihui Xie [ctb], Zhuoer Dong [ctb], Hadley Wickham [ctb], Jeffrey Horner [ctb], reikoch [ctb], Will Beasley [ctb], Brendan O'Connor [ctb], Gregory R. Warnes [ctb], Michael Quinn [ctb], Zhian N. Kamvar [ctb], Charlie Gao [ctb]", + "Maintainer": "Shawn Garbett ", + "License": "BSD_3_clause + file LICENSE", + "Description": "Implements the 'libyaml' 'YAML' 1.1 parser and emitter () for R.", + "URL": "https://github.com/vubiostat/r-yaml/", + "BugReports": "https://github.com/vubiostat/r-yaml/issues", + "NeedsCompilation": "yes", + "Repository": "CRAN" + } + } +} diff --git a/renv/.gitignore b/renv/.gitignore new file mode 100644 index 0000000..0ec0cbb --- /dev/null +++ b/renv/.gitignore @@ -0,0 +1,7 @@ +library/ +local/ +cellar/ +lock/ +python/ +sandbox/ +staging/ diff --git a/renv/activate.R b/renv/activate.R new file mode 100644 index 0000000..2753ae5 --- /dev/null +++ b/renv/activate.R @@ -0,0 +1,1334 @@ + +local({ + + # the requested version of renv + version <- "1.1.5" + attr(version, "sha") <- NULL + + # the project directory + project <- Sys.getenv("RENV_PROJECT") + if (!nzchar(project)) + project <- getwd() + + # use start-up diagnostics if enabled + diagnostics <- Sys.getenv("RENV_STARTUP_DIAGNOSTICS", unset = "FALSE") + if (diagnostics) { + start <- Sys.time() + profile <- tempfile("renv-startup-", fileext = ".Rprof") + utils::Rprof(profile) + on.exit({ + utils::Rprof(NULL) + elapsed <- signif(difftime(Sys.time(), start, units = "auto"), digits = 2L) + writeLines(sprintf("- renv took %s to run the autoloader.", format(elapsed))) + writeLines(sprintf("- Profile: %s", profile)) + print(utils::summaryRprof(profile)) + }, add = TRUE) + } + + # figure out whether the autoloader is enabled + enabled <- local({ + + # first, check config option + override <- getOption("renv.config.autoloader.enabled") + if (!is.null(override)) + return(override) + + # if we're being run in a context where R_LIBS is already set, + # don't load -- presumably we're being run as a sub-process and + # the parent process has already set up library paths for us + rcmd <- Sys.getenv("R_CMD", unset = NA) + rlibs <- Sys.getenv("R_LIBS", unset = NA) + if (!is.na(rlibs) && !is.na(rcmd)) + return(FALSE) + + # next, check environment variables + # prefer using the configuration one in the future + envvars <- c( + "RENV_CONFIG_AUTOLOADER_ENABLED", + "RENV_AUTOLOADER_ENABLED", + "RENV_ACTIVATE_PROJECT" + ) + + for (envvar in envvars) { + envval <- Sys.getenv(envvar, unset = NA) + if (!is.na(envval)) + return(tolower(envval) %in% c("true", "t", "1")) + } + + # enable by default + TRUE + + }) + + # bail if we're not enabled + if (!enabled) { + + # if we're not enabled, we might still need to manually load + # the user profile here + profile <- Sys.getenv("R_PROFILE_USER", unset = "~/.Rprofile") + if (file.exists(profile)) { + cfg <- Sys.getenv("RENV_CONFIG_USER_PROFILE", unset = "TRUE") + if (tolower(cfg) %in% c("true", "t", "1")) + sys.source(profile, envir = globalenv()) + } + + return(FALSE) + + } + + # avoid recursion + if (identical(getOption("renv.autoloader.running"), TRUE)) { + warning("ignoring recursive attempt to run renv autoloader") + return(invisible(TRUE)) + } + + # signal that we're loading renv during R startup + options(renv.autoloader.running = TRUE) + on.exit(options(renv.autoloader.running = NULL), add = TRUE) + + # signal that we've consented to use renv + options(renv.consent = TRUE) + + # load the 'utils' package eagerly -- this ensures that renv shims, which + # mask 'utils' packages, will come first on the search path + library(utils, lib.loc = .Library) + + # unload renv if it's already been loaded + if ("renv" %in% loadedNamespaces()) + unloadNamespace("renv") + + # load bootstrap tools + ansify <- function(text) { + if (renv_ansify_enabled()) + renv_ansify_enhanced(text) + else + renv_ansify_default(text) + } + + renv_ansify_enabled <- function() { + + override <- Sys.getenv("RENV_ANSIFY_ENABLED", unset = NA) + if (!is.na(override)) + return(as.logical(override)) + + pane <- Sys.getenv("RSTUDIO_CHILD_PROCESS_PANE", unset = NA) + if (identical(pane, "build")) + return(FALSE) + + testthat <- Sys.getenv("TESTTHAT", unset = "false") + if (tolower(testthat) %in% "true") + return(FALSE) + + iderun <- Sys.getenv("R_CLI_HAS_HYPERLINK_IDE_RUN", unset = "false") + if (tolower(iderun) %in% "false") + return(FALSE) + + TRUE + + } + + renv_ansify_default <- function(text) { + text + } + + renv_ansify_enhanced <- function(text) { + + # R help links + pattern <- "`\\?(renv::(?:[^`])+)`" + replacement <- "`\033]8;;x-r-help:\\1\a?\\1\033]8;;\a`" + text <- gsub(pattern, replacement, text, perl = TRUE) + + # runnable code + pattern <- "`(renv::(?:[^`])+)`" + replacement <- "`\033]8;;x-r-run:\\1\a\\1\033]8;;\a`" + text <- gsub(pattern, replacement, text, perl = TRUE) + + # return ansified text + text + + } + + renv_ansify_init <- function() { + + envir <- renv_envir_self() + if (renv_ansify_enabled()) + assign("ansify", renv_ansify_enhanced, envir = envir) + else + assign("ansify", renv_ansify_default, envir = envir) + + } + + `%||%` <- function(x, y) { + if (is.null(x)) y else x + } + + catf <- function(fmt, ..., appendLF = TRUE) { + + quiet <- getOption("renv.bootstrap.quiet", default = FALSE) + if (quiet) + return(invisible()) + + msg <- sprintf(fmt, ...) + cat(msg, file = stdout(), sep = if (appendLF) "\n" else "") + + invisible(msg) + + } + + header <- function(label, + ..., + prefix = "#", + suffix = "-", + n = min(getOption("width"), 78)) + { + label <- sprintf(label, ...) + n <- max(n - nchar(label) - nchar(prefix) - 2L, 8L) + if (n <= 0) + return(paste(prefix, label)) + + tail <- paste(rep.int(suffix, n), collapse = "") + paste0(prefix, " ", label, " ", tail) + + } + + heredoc <- function(text, leave = 0) { + + # remove leading, trailing whitespace + trimmed <- gsub("^\\s*\\n|\\n\\s*$", "", text) + + # split into lines + lines <- strsplit(trimmed, "\n", fixed = TRUE)[[1L]] + + # compute common indent + indent <- regexpr("[^[:space:]]", lines) + common <- min(setdiff(indent, -1L)) - leave + text <- paste(substring(lines, common), collapse = "\n") + + # substitute in ANSI links for executable renv code + ansify(text) + + } + + bootstrap <- function(version, library) { + + friendly <- renv_bootstrap_version_friendly(version) + section <- header(sprintf("Bootstrapping renv %s", friendly)) + catf(section) + + # attempt to download renv + catf("- Downloading renv ... ", appendLF = FALSE) + withCallingHandlers( + tarball <- renv_bootstrap_download(version), + error = function(err) { + catf("FAILED") + stop("failed to download:\n", conditionMessage(err)) + } + ) + catf("OK") + on.exit(unlink(tarball), add = TRUE) + + # now attempt to install + catf("- Installing renv ... ", appendLF = FALSE) + withCallingHandlers( + status <- renv_bootstrap_install(version, tarball, library), + error = function(err) { + catf("FAILED") + stop("failed to install:\n", conditionMessage(err)) + } + ) + catf("OK") + + # add empty line to break up bootstrapping from normal output + catf("") + + return(invisible()) + } + + renv_bootstrap_tests_running <- function() { + getOption("renv.tests.running", default = FALSE) + } + + renv_bootstrap_repos <- function() { + + # get CRAN repository + cran <- getOption("renv.repos.cran", "https://cloud.r-project.org") + + # check for repos override + repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA) + if (!is.na(repos)) { + + # check for RSPM; if set, use a fallback repository for renv + rspm <- Sys.getenv("RSPM", unset = NA) + if (identical(rspm, repos)) + repos <- c(RSPM = rspm, CRAN = cran) + + return(repos) + + } + + # check for lockfile repositories + repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity) + if (!inherits(repos, "error") && length(repos)) + return(repos) + + # retrieve current repos + repos <- getOption("repos") + + # ensure @CRAN@ entries are resolved + repos[repos == "@CRAN@"] <- cran + + # add in renv.bootstrap.repos if set + default <- c(FALLBACK = "https://cloud.r-project.org") + extra <- getOption("renv.bootstrap.repos", default = default) + repos <- c(repos, extra) + + # remove duplicates that might've snuck in + dupes <- duplicated(repos) | duplicated(names(repos)) + repos[!dupes] + + } + + renv_bootstrap_repos_lockfile <- function() { + + lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock") + if (!file.exists(lockpath)) + return(NULL) + + lockfile <- tryCatch(renv_json_read(lockpath), error = identity) + if (inherits(lockfile, "error")) { + warning(lockfile) + return(NULL) + } + + repos <- lockfile$R$Repositories + if (length(repos) == 0) + return(NULL) + + keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1)) + vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1)) + names(vals) <- keys + + return(vals) + + } + + renv_bootstrap_download <- function(version) { + + sha <- attr(version, "sha", exact = TRUE) + + methods <- if (!is.null(sha)) { + + # attempting to bootstrap a development version of renv + c( + function() renv_bootstrap_download_tarball(sha), + function() renv_bootstrap_download_github(sha) + ) + + } else { + + # attempting to bootstrap a release version of renv + c( + function() renv_bootstrap_download_tarball(version), + function() renv_bootstrap_download_cran_latest(version), + function() renv_bootstrap_download_cran_archive(version) + ) + + } + + for (method in methods) { + path <- tryCatch(method(), error = identity) + if (is.character(path) && file.exists(path)) + return(path) + } + + stop("All download methods failed") + + } + + renv_bootstrap_download_impl <- function(url, destfile) { + + mode <- "wb" + + # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715 + fixup <- + Sys.info()[["sysname"]] == "Windows" && + substring(url, 1L, 5L) == "file:" + + if (fixup) + mode <- "w+b" + + args <- list( + url = url, + destfile = destfile, + mode = mode, + quiet = TRUE + ) + + if ("headers" %in% names(formals(utils::download.file))) { + headers <- renv_bootstrap_download_custom_headers(url) + if (length(headers) && is.character(headers)) + args$headers <- headers + } + + do.call(utils::download.file, args) + + } + + renv_bootstrap_download_custom_headers <- function(url) { + + headers <- getOption("renv.download.headers") + if (is.null(headers)) + return(character()) + + if (!is.function(headers)) + stopf("'renv.download.headers' is not a function") + + headers <- headers(url) + if (length(headers) == 0L) + return(character()) + + if (is.list(headers)) + headers <- unlist(headers, recursive = FALSE, use.names = TRUE) + + ok <- + is.character(headers) && + is.character(names(headers)) && + all(nzchar(names(headers))) + + if (!ok) + stop("invocation of 'renv.download.headers' did not return a named character vector") + + headers + + } + + renv_bootstrap_download_cran_latest <- function(version) { + + spec <- renv_bootstrap_download_cran_latest_find(version) + type <- spec$type + repos <- spec$repos + + baseurl <- utils::contrib.url(repos = repos, type = type) + ext <- if (identical(type, "source")) + ".tar.gz" + else if (Sys.info()[["sysname"]] == "Windows") + ".zip" + else + ".tgz" + name <- sprintf("renv_%s%s", version, ext) + url <- paste(baseurl, name, sep = "/") + + destfile <- file.path(tempdir(), name) + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (inherits(status, "condition")) + return(FALSE) + + # report success and return + destfile + + } + + renv_bootstrap_download_cran_latest_find <- function(version) { + + # check whether binaries are supported on this system + binary <- + getOption("renv.bootstrap.binary", default = TRUE) && + !identical(.Platform$pkgType, "source") && + !identical(getOption("pkgType"), "source") && + Sys.info()[["sysname"]] %in% c("Darwin", "Windows") + + types <- c(if (binary) "binary", "source") + + # iterate over types + repositories + for (type in types) { + for (repos in renv_bootstrap_repos()) { + + # build arguments for utils::available.packages() call + args <- list(type = type, repos = repos) + + # add custom headers if available -- note that + # utils::available.packages() will pass this to download.file() + if ("headers" %in% names(formals(utils::download.file))) { + headers <- renv_bootstrap_download_custom_headers(repos) + if (length(headers) && is.character(headers)) + args$headers <- headers + } + + # retrieve package database + db <- tryCatch( + as.data.frame( + do.call(utils::available.packages, args), + stringsAsFactors = FALSE + ), + error = identity + ) + + if (inherits(db, "error")) + next + + # check for compatible entry + entry <- db[db$Package %in% "renv" & db$Version %in% version, ] + if (nrow(entry) == 0) + next + + # found it; return spec to caller + spec <- list(entry = entry, type = type, repos = repos) + return(spec) + + } + } + + # if we got here, we failed to find renv + fmt <- "renv %s is not available from your declared package repositories" + stop(sprintf(fmt, version)) + + } + + renv_bootstrap_download_cran_archive <- function(version) { + + name <- sprintf("renv_%s.tar.gz", version) + repos <- renv_bootstrap_repos() + urls <- file.path(repos, "src/contrib/Archive/renv", name) + destfile <- file.path(tempdir(), name) + + for (url in urls) { + + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (identical(status, 0L)) + return(destfile) + + } + + return(FALSE) + + } + + renv_bootstrap_download_tarball <- function(version) { + + # if the user has provided the path to a tarball via + # an environment variable, then use it + tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA) + if (is.na(tarball)) + return() + + # allow directories + if (dir.exists(tarball)) { + name <- sprintf("renv_%s.tar.gz", version) + tarball <- file.path(tarball, name) + } + + # bail if it doesn't exist + if (!file.exists(tarball)) { + + # let the user know we weren't able to honour their request + fmt <- "- RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist." + msg <- sprintf(fmt, tarball) + warning(msg) + + # bail + return() + + } + + catf("- Using local tarball '%s'.", tarball) + tarball + + } + + renv_bootstrap_github_token <- function() { + for (envvar in c("GITHUB_TOKEN", "GITHUB_PAT", "GH_TOKEN")) { + envval <- Sys.getenv(envvar, unset = NA) + if (!is.na(envval)) + return(envval) + } + } + + renv_bootstrap_download_github <- function(version) { + + enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE") + if (!identical(enabled, "TRUE")) + return(FALSE) + + # prepare download options + token <- renv_bootstrap_github_token() + if (is.null(token)) + token <- "" + + if (nzchar(Sys.which("curl")) && nzchar(token)) { + fmt <- "--location --fail --header \"Authorization: token %s\"" + extra <- sprintf(fmt, token) + saved <- options("download.file.method", "download.file.extra") + options(download.file.method = "curl", download.file.extra = extra) + on.exit(do.call(base::options, saved), add = TRUE) + } else if (nzchar(Sys.which("wget")) && nzchar(token)) { + fmt <- "--header=\"Authorization: token %s\"" + extra <- sprintf(fmt, token) + saved <- options("download.file.method", "download.file.extra") + options(download.file.method = "wget", download.file.extra = extra) + on.exit(do.call(base::options, saved), add = TRUE) + } + + url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version) + name <- sprintf("renv_%s.tar.gz", version) + destfile <- file.path(tempdir(), name) + + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (!identical(status, 0L)) + return(FALSE) + + renv_bootstrap_download_augment(destfile) + + return(destfile) + + } + + # Add Sha to DESCRIPTION. This is stop gap until #890, after which we + # can use renv::install() to fully capture metadata. + renv_bootstrap_download_augment <- function(destfile) { + sha <- renv_bootstrap_git_extract_sha1_tar(destfile) + if (is.null(sha)) { + return() + } + + # Untar + tempdir <- tempfile("renv-github-") + on.exit(unlink(tempdir, recursive = TRUE), add = TRUE) + untar(destfile, exdir = tempdir) + pkgdir <- dir(tempdir, full.names = TRUE)[[1]] + + # Modify description + desc_path <- file.path(pkgdir, "DESCRIPTION") + desc_lines <- readLines(desc_path) + remotes_fields <- c( + "RemoteType: github", + "RemoteHost: api.github.com", + "RemoteRepo: renv", + "RemoteUsername: rstudio", + "RemotePkgRef: rstudio/renv", + paste("RemoteRef: ", sha), + paste("RemoteSha: ", sha) + ) + writeLines(c(desc_lines[desc_lines != ""], remotes_fields), con = desc_path) + + # Re-tar + local({ + old <- setwd(tempdir) + on.exit(setwd(old), add = TRUE) + + tar(destfile, compression = "gzip") + }) + invisible() + } + + # Extract the commit hash from a git archive. Git archives include the SHA1 + # hash as the comment field of the tarball pax extended header + # (see https://www.kernel.org/pub/software/scm/git/docs/git-archive.html) + # For GitHub archives this should be the first header after the default one + # (512 byte) header. + renv_bootstrap_git_extract_sha1_tar <- function(bundle) { + + # open the bundle for reading + # We use gzcon for everything because (from ?gzcon) + # > Reading from a connection which does not supply a 'gzip' magic + # > header is equivalent to reading from the original connection + conn <- gzcon(file(bundle, open = "rb", raw = TRUE)) + on.exit(close(conn)) + + # The default pax header is 512 bytes long and the first pax extended header + # with the comment should be 51 bytes long + # `52 comment=` (11 chars) + 40 byte SHA1 hash + len <- 0x200 + 0x33 + res <- rawToChar(readBin(conn, "raw", n = len)[0x201:len]) + + if (grepl("^52 comment=", res)) { + sub("52 comment=", "", res) + } else { + NULL + } + } + + renv_bootstrap_install <- function(version, tarball, library) { + + # attempt to install it into project library + dir.create(library, showWarnings = FALSE, recursive = TRUE) + output <- renv_bootstrap_install_impl(library, tarball) + + # check for successful install + status <- attr(output, "status") + if (is.null(status) || identical(status, 0L)) + return(status) + + # an error occurred; report it + header <- "installation of renv failed" + lines <- paste(rep.int("=", nchar(header)), collapse = "") + text <- paste(c(header, lines, output), collapse = "\n") + stop(text) + + } + + renv_bootstrap_install_impl <- function(library, tarball) { + + # invoke using system2 so we can capture and report output + bin <- R.home("bin") + exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R" + R <- file.path(bin, exe) + + args <- c( + "--vanilla", "CMD", "INSTALL", "--no-multiarch", + "-l", shQuote(path.expand(library)), + shQuote(path.expand(tarball)) + ) + + system2(R, args, stdout = TRUE, stderr = TRUE) + + } + + renv_bootstrap_platform_prefix_default <- function() { + + # read version component + version <- Sys.getenv("RENV_PATHS_VERSION", unset = "R-%v") + + # expand placeholders + placeholders <- list( + list("%v", format(getRversion()[1, 1:2])), + list("%V", format(getRversion()[1, 1:3])) + ) + + for (placeholder in placeholders) + version <- gsub(placeholder[[1L]], placeholder[[2L]], version, fixed = TRUE) + + # include SVN revision for development versions of R + # (to avoid sharing platform-specific artefacts with released versions of R) + devel <- + identical(R.version[["status"]], "Under development (unstable)") || + identical(R.version[["nickname"]], "Unsuffered Consequences") + + if (devel) + version <- paste(version, R.version[["svn rev"]], sep = "-r") + + version + + } + + renv_bootstrap_platform_prefix <- function() { + + # construct version prefix + version <- renv_bootstrap_platform_prefix_default() + + # build list of path components + components <- c(version, R.version$platform) + + # include prefix if provided by user + prefix <- renv_bootstrap_platform_prefix_impl() + if (!is.na(prefix) && nzchar(prefix)) + components <- c(prefix, components) + + # build prefix + paste(components, collapse = "/") + + } + + renv_bootstrap_platform_prefix_impl <- function() { + + # if an explicit prefix has been supplied, use it + prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA) + if (!is.na(prefix)) + return(prefix) + + # if the user has requested an automatic prefix, generate it + auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA) + if (is.na(auto) && getRversion() >= "4.4.0") + auto <- "TRUE" + + if (auto %in% c("TRUE", "True", "true", "1")) + return(renv_bootstrap_platform_prefix_auto()) + + # empty string on failure + "" + + } + + renv_bootstrap_platform_prefix_auto <- function() { + + prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity) + if (inherits(prefix, "error") || prefix %in% "unknown") { + + msg <- paste( + "failed to infer current operating system", + "please file a bug report at https://github.com/rstudio/renv/issues", + sep = "; " + ) + + warning(msg) + + } + + prefix + + } + + renv_bootstrap_platform_os <- function() { + + sysinfo <- Sys.info() + sysname <- sysinfo[["sysname"]] + + # handle Windows + macOS up front + if (sysname == "Windows") + return("windows") + else if (sysname == "Darwin") + return("macos") + + # check for os-release files + for (file in c("/etc/os-release", "/usr/lib/os-release")) + if (file.exists(file)) + return(renv_bootstrap_platform_os_via_os_release(file, sysinfo)) + + # check for redhat-release files + if (file.exists("/etc/redhat-release")) + return(renv_bootstrap_platform_os_via_redhat_release()) + + "unknown" + + } + + renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) { + + # read /etc/os-release + release <- utils::read.table( + file = file, + sep = "=", + quote = c("\"", "'"), + col.names = c("Key", "Value"), + comment.char = "#", + stringsAsFactors = FALSE + ) + + vars <- as.list(release$Value) + names(vars) <- release$Key + + # get os name + os <- tolower(sysinfo[["sysname"]]) + + # read id + id <- "unknown" + for (field in c("ID", "ID_LIKE")) { + if (field %in% names(vars) && nzchar(vars[[field]])) { + id <- vars[[field]] + break + } + } + + # read version + version <- "unknown" + for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) { + if (field %in% names(vars) && nzchar(vars[[field]])) { + version <- vars[[field]] + break + } + } + + # join together + paste(c(os, id, version), collapse = "-") + + } + + renv_bootstrap_platform_os_via_redhat_release <- function() { + + # read /etc/redhat-release + contents <- readLines("/etc/redhat-release", warn = FALSE) + + # infer id + id <- if (grepl("centos", contents, ignore.case = TRUE)) + "centos" + else if (grepl("redhat", contents, ignore.case = TRUE)) + "redhat" + else + "unknown" + + # try to find a version component (very hacky) + version <- "unknown" + + parts <- strsplit(contents, "[[:space:]]")[[1L]] + for (part in parts) { + + nv <- tryCatch(numeric_version(part), error = identity) + if (inherits(nv, "error")) + next + + version <- nv[1, 1] + break + + } + + paste(c("linux", id, version), collapse = "-") + + } + + renv_bootstrap_library_root_name <- function(project) { + + # use project name as-is if requested + asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE") + if (asis) + return(basename(project)) + + # otherwise, disambiguate based on project's path + id <- substring(renv_bootstrap_hash_text(project), 1L, 8L) + paste(basename(project), id, sep = "-") + + } + + renv_bootstrap_library_root <- function(project) { + + prefix <- renv_bootstrap_profile_prefix() + + path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA) + if (!is.na(path)) + return(paste(c(path, prefix), collapse = "/")) + + path <- renv_bootstrap_library_root_impl(project) + if (!is.null(path)) { + name <- renv_bootstrap_library_root_name(project) + return(paste(c(path, prefix, name), collapse = "/")) + } + + renv_bootstrap_paths_renv("library", project = project) + + } + + renv_bootstrap_library_root_impl <- function(project) { + + root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA) + if (!is.na(root)) + return(root) + + type <- renv_bootstrap_project_type(project) + if (identical(type, "package")) { + userdir <- renv_bootstrap_user_dir() + return(file.path(userdir, "library")) + } + + } + + renv_bootstrap_validate_version <- function(version, description = NULL) { + + # resolve description file + # + # avoid passing lib.loc to `packageDescription()` below, since R will + # use the loaded version of the package by default anyhow. note that + # this function should only be called after 'renv' is loaded + # https://github.com/rstudio/renv/issues/1625 + description <- description %||% packageDescription("renv") + + # check whether requested version 'version' matches loaded version of renv + sha <- attr(version, "sha", exact = TRUE) + valid <- if (!is.null(sha)) + renv_bootstrap_validate_version_dev(sha, description) + else + renv_bootstrap_validate_version_release(version, description) + + if (valid) + return(TRUE) + + # the loaded version of renv doesn't match the requested version; + # give the user instructions on how to proceed + dev <- identical(description[["RemoteType"]], "github") + remote <- if (dev) + paste("rstudio/renv", description[["RemoteSha"]], sep = "@") + else + paste("renv", description[["Version"]], sep = "@") + + # display both loaded version + sha if available + friendly <- renv_bootstrap_version_friendly( + version = description[["Version"]], + sha = if (dev) description[["RemoteSha"]] + ) + + fmt <- heredoc(" + renv %1$s was loaded from project library, but this project is configured to use renv %2$s. + - Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile. + - Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library. + ") + catf(fmt, friendly, renv_bootstrap_version_friendly(version), remote) + + FALSE + + } + + renv_bootstrap_validate_version_dev <- function(version, description) { + + expected <- description[["RemoteSha"]] + if (!is.character(expected)) + return(FALSE) + + pattern <- sprintf("^\\Q%s\\E", version) + grepl(pattern, expected, perl = TRUE) + + } + + renv_bootstrap_validate_version_release <- function(version, description) { + expected <- description[["Version"]] + is.character(expected) && identical(expected, version) + } + + renv_bootstrap_hash_text <- function(text) { + + hashfile <- tempfile("renv-hash-") + on.exit(unlink(hashfile), add = TRUE) + + writeLines(text, con = hashfile) + tools::md5sum(hashfile) + + } + + renv_bootstrap_load <- function(project, libpath, version) { + + # try to load renv from the project library + if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) + return(FALSE) + + # warn if the version of renv loaded does not match + renv_bootstrap_validate_version(version) + + # execute renv load hooks, if any + hooks <- getHook("renv::autoload") + for (hook in hooks) + if (is.function(hook)) + tryCatch(hook(), error = warnify) + + # load the project + renv::load(project) + + TRUE + + } + + renv_bootstrap_profile_load <- function(project) { + + # if RENV_PROFILE is already set, just use that + profile <- Sys.getenv("RENV_PROFILE", unset = NA) + if (!is.na(profile) && nzchar(profile)) + return(profile) + + # check for a profile file (nothing to do if it doesn't exist) + path <- renv_bootstrap_paths_renv("profile", profile = FALSE, project = project) + if (!file.exists(path)) + return(NULL) + + # read the profile, and set it if it exists + contents <- readLines(path, warn = FALSE) + if (length(contents) == 0L) + return(NULL) + + # set RENV_PROFILE + profile <- contents[[1L]] + if (!profile %in% c("", "default")) + Sys.setenv(RENV_PROFILE = profile) + + profile + + } + + renv_bootstrap_profile_prefix <- function() { + profile <- renv_bootstrap_profile_get() + if (!is.null(profile)) + return(file.path("profiles", profile, "renv")) + } + + renv_bootstrap_profile_get <- function() { + profile <- Sys.getenv("RENV_PROFILE", unset = "") + renv_bootstrap_profile_normalize(profile) + } + + renv_bootstrap_profile_set <- function(profile) { + profile <- renv_bootstrap_profile_normalize(profile) + if (is.null(profile)) + Sys.unsetenv("RENV_PROFILE") + else + Sys.setenv(RENV_PROFILE = profile) + } + + renv_bootstrap_profile_normalize <- function(profile) { + + if (is.null(profile) || profile %in% c("", "default")) + return(NULL) + + profile + + } + + renv_bootstrap_path_absolute <- function(path) { + + substr(path, 1L, 1L) %in% c("~", "/", "\\") || ( + substr(path, 1L, 1L) %in% c(letters, LETTERS) && + substr(path, 2L, 3L) %in% c(":/", ":\\") + ) + + } + + renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) { + renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv") + root <- if (renv_bootstrap_path_absolute(renv)) NULL else project + prefix <- if (profile) renv_bootstrap_profile_prefix() + components <- c(root, renv, prefix, ...) + paste(components, collapse = "/") + } + + renv_bootstrap_project_type <- function(path) { + + descpath <- file.path(path, "DESCRIPTION") + if (!file.exists(descpath)) + return("unknown") + + desc <- tryCatch( + read.dcf(descpath, all = TRUE), + error = identity + ) + + if (inherits(desc, "error")) + return("unknown") + + type <- desc$Type + if (!is.null(type)) + return(tolower(type)) + + package <- desc$Package + if (!is.null(package)) + return("package") + + "unknown" + + } + + renv_bootstrap_user_dir <- function() { + dir <- renv_bootstrap_user_dir_impl() + path.expand(chartr("\\", "/", dir)) + } + + renv_bootstrap_user_dir_impl <- function() { + + # use local override if set + override <- getOption("renv.userdir.override") + if (!is.null(override)) + return(override) + + # use R_user_dir if available + tools <- asNamespace("tools") + if (is.function(tools$R_user_dir)) + return(tools$R_user_dir("renv", "cache")) + + # try using our own backfill for older versions of R + envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME") + for (envvar in envvars) { + root <- Sys.getenv(envvar, unset = NA) + if (!is.na(root)) + return(file.path(root, "R/renv")) + } + + # use platform-specific default fallbacks + if (Sys.info()[["sysname"]] == "Windows") + file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv") + else if (Sys.info()[["sysname"]] == "Darwin") + "~/Library/Caches/org.R-project.R/R/renv" + else + "~/.cache/R/renv" + + } + + renv_bootstrap_version_friendly <- function(version, shafmt = NULL, sha = NULL) { + sha <- sha %||% attr(version, "sha", exact = TRUE) + parts <- c(version, sprintf(shafmt %||% " [sha: %s]", substring(sha, 1L, 7L))) + paste(parts, collapse = "") + } + + renv_bootstrap_exec <- function(project, libpath, version) { + if (!renv_bootstrap_load(project, libpath, version)) + renv_bootstrap_run(project, libpath, version) + } + + renv_bootstrap_run <- function(project, libpath, version) { + + # perform bootstrap + bootstrap(version, libpath) + + # exit early if we're just testing bootstrap + if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA))) + return(TRUE) + + # try again to load + if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) { + return(renv::load(project = project)) + } + + # failed to download or load renv; warn the user + msg <- c( + "Failed to find an renv installation: the project will not be loaded.", + "Use `renv::activate()` to re-initialize the project." + ) + + warning(paste(msg, collapse = "\n"), call. = FALSE) + + } + + renv_json_read <- function(file = NULL, text = NULL) { + + jlerr <- NULL + + # if jsonlite is loaded, use that instead + if ("jsonlite" %in% loadedNamespaces()) { + + json <- tryCatch(renv_json_read_jsonlite(file, text), error = identity) + if (!inherits(json, "error")) + return(json) + + jlerr <- json + + } + + # otherwise, fall back to the default JSON reader + json <- tryCatch(renv_json_read_default(file, text), error = identity) + if (!inherits(json, "error")) + return(json) + + # report an error + if (!is.null(jlerr)) + stop(jlerr) + else + stop(json) + + } + + renv_json_read_jsonlite <- function(file = NULL, text = NULL) { + text <- paste(text %||% readLines(file, warn = FALSE), collapse = "\n") + jsonlite::fromJSON(txt = text, simplifyVector = FALSE) + } + + renv_json_read_patterns <- function() { + + list( + + # objects + list("{", "\t\n\tobject(\t\n\t", TRUE), + list("}", "\t\n\t)\t\n\t", TRUE), + + # arrays + list("[", "\t\n\tarray(\t\n\t", TRUE), + list("]", "\n\t\n)\n\t\n", TRUE), + + # maps + list(":", "\t\n\t=\t\n\t", TRUE), + + # newlines + list("\\u000a", "\n", FALSE) + + ) + + } + + renv_json_read_envir <- function() { + + envir <- new.env(parent = emptyenv()) + + envir[["+"]] <- `+` + envir[["-"]] <- `-` + + envir[["object"]] <- function(...) { + result <- list(...) + names(result) <- as.character(names(result)) + result + } + + envir[["array"]] <- list + + envir[["true"]] <- TRUE + envir[["false"]] <- FALSE + envir[["null"]] <- NULL + + envir + + } + + renv_json_read_remap <- function(object, patterns) { + + # repair names if necessary + if (!is.null(names(object))) { + + nms <- names(object) + for (pattern in patterns) + nms <- gsub(pattern[[2L]], pattern[[1L]], nms, fixed = TRUE) + names(object) <- nms + + } + + # repair strings if necessary + if (is.character(object)) { + for (pattern in patterns) + object <- gsub(pattern[[2L]], pattern[[1L]], object, fixed = TRUE) + } + + # recurse for other objects + if (is.recursive(object)) + for (i in seq_along(object)) + object[i] <- list(renv_json_read_remap(object[[i]], patterns)) + + # return remapped object + object + + } + + renv_json_read_default <- function(file = NULL, text = NULL) { + + # read json text + text <- paste(text %||% readLines(file, warn = FALSE), collapse = "\n") + + # convert into something the R parser will understand + patterns <- renv_json_read_patterns() + transformed <- text + for (pattern in patterns) + transformed <- gsub(pattern[[1L]], pattern[[2L]], transformed, fixed = TRUE) + + # parse it + rfile <- tempfile("renv-json-", fileext = ".R") + on.exit(unlink(rfile), add = TRUE) + writeLines(transformed, con = rfile) + json <- parse(rfile, keep.source = FALSE, srcfile = NULL)[[1L]] + + # evaluate in safe environment + result <- eval(json, envir = renv_json_read_envir()) + + # fix up strings if necessary -- do so only with reversible patterns + patterns <- Filter(function(pattern) pattern[[3L]], patterns) + renv_json_read_remap(result, patterns) + + } + + + # load the renv profile, if any + renv_bootstrap_profile_load(project) + + # construct path to library root + root <- renv_bootstrap_library_root(project) + + # construct library prefix for platform + prefix <- renv_bootstrap_platform_prefix() + + # construct full libpath + libpath <- file.path(root, prefix) + + # run bootstrap code + renv_bootstrap_exec(project, libpath, version) + + invisible() + +}) diff --git a/resources/RStudio-Logo-Flat.png b/resources/RStudio-Logo-Flat.png new file mode 100644 index 0000000..385c98b Binary files /dev/null and b/resources/RStudio-Logo-Flat.png differ diff --git a/resources/RenduExercice.png b/resources/RenduExercice.png new file mode 100644 index 0000000..fa9f879 Binary files /dev/null and b/resources/RenduExercice.png differ diff --git a/fenetreRStudio.png b/resources/fenetreRStudio.png similarity index 100% rename from fenetreRStudio.png rename to resources/fenetreRStudio.png diff --git a/resources/rstudio_package_install.png b/resources/rstudio_package_install.png new file mode 100644 index 0000000..03206b9 Binary files /dev/null and b/resources/rstudio_package_install.png differ diff --git a/resources/rstudio_package_install2.png b/resources/rstudio_package_install2.png new file mode 100644 index 0000000..304e4b5 Binary files /dev/null and b/resources/rstudio_package_install2.png differ diff --git a/rl3.Rproj b/rl3.Rproj index 8e3c2eb..a680331 100644 --- a/rl3.Rproj +++ b/rl3.Rproj @@ -11,3 +11,5 @@ Encoding: UTF-8 RnwWeave: Sweave LaTeX: pdfLaTeX + +SpellingDictionary: fr_FR diff --git a/slidesrl3.html b/slidesrl3.html deleted file mode 100644 index 58e502e..0000000 --- a/slidesrl3.html +++ /dev/null @@ -1,1435 +0,0 @@ - - - - Une introduction à R - - - - - - - - - - - - - - - - - - diff --git a/slidesrl3.rmd b/slidesrl3.rmd deleted file mode 100644 index 5b71950..0000000 --- a/slidesrl3.rmd +++ /dev/null @@ -1,902 +0,0 @@ ---- -title: "Une introduction à R" -subtitle: "L3 économie-finance" -author: "Élias Bouacida ; Antoine Terracol" -institute: "Université Paris 8" -date: "`r Sys.Date()`" -output: - xaringan::moon_reader: - css: ["default","style_perso.css"] - self_contained: true - nature: - highlightStyle: github - highlightLines: true - countIncrementalSlides: false - ratio: "16:9" - ---- - - -```{r setup, include=FALSE} -options(htmltools.dir.version = FALSE) -knitr::opts_chunk$set(fig.retina = 3, warning = FALSE, message = FALSE) -``` - - -class: left, top -name: Installation - -# Installation - -Le seul prérequis pour suivre ce cours est d'avoir installé R et RStudio sur votre ordinateur. - -Il s'agit de deux logiciels libres, gratuits, téléchargeables en ligne et fonctionnant sous Windows, Mac et Linux. - -Pour installer R, il suffit de se rendre sur une des pages suivantes : - -[Installer R sous Windows](https://cloud.r-project.org/bin/windows/base/) - -[Installer R sous Mac](https://cloud.r-project.org/bin/macosx/) - -Pour installer RStudio, rendez-vous sur [la page de téléchargement du logiciel](https://www.rstudio.com/products/rstudio/download/#download) et installez la version adaptée à votre système. - -Vous trouverez plus d'informations sur l'installation de R et Rstudio sur le page Moodle du cours. - ---- -class:inverse -# Prise en main - ---- -class: left, top - - -## La console - -Au premier lancement de RStudio, l'interface est organisée en trois grandes zones. - -```{r, out.width = "600px",echo=FALSE} -knitr::include_graphics("fenetreRStudio.png") -``` - - - -La zone de gauche se nomme la Console. À son démarrage, RStudio a lancé une nouvelle session de R et c'est dans cette fenêtre que nous allons pouvoir interagir avec lui. ---- -La Console affiche un texte de bienvenue suivi d'une ligne commençant par le caractère `>` (l'invite de commande). - - -Nous pouvons tout de suite essayer quelques calculs : - -```{r} -2+2 -``` --- - -```{r} -5-7 -4*12 --10/3 -5^2 -``` - ---- -## Calculs de base - - - - -#### Addition, Sousraction, Multiplication et Division - -| Math | code `R` | Résultat | -|:-------------:|:-------:|:---------:| -| $3 + 2$ | `3 + 2` | `r 3 + 2` | -| $3 - 2$ | `3 - 2` | `r 3 - 2` | -| $3 \times 2$ | `3 * 2` | `r 3 * 2` | -| $3 \div 2$ | `3 / 2` | `r 3 / 2` | - -#### Exposants - -| Math | code `R` | Résultat | -|:-------------:|:-------:|:---------:| -| $3^2$ | `3 ^ 2` | `r 3 ^ 2` | -| $2^{(-3)}$ | `2 ^ (-3)` | `r 2 ^ (-3)` | -| $100^{1/2}$ | `100 ^ (1 / 2)` | `r 100 ^ (1 / 2)` | -| $\sqrt{100}$ | `sqrt(100)` | `r sqrt(100)` | - ---- - -#### Constantes mathématiques - -| Math | code `R` | Résultat | -|:------------:|:---------------:|:-----------------:| -| $\pi$ | `pi` | `3.141593` | -| $e$ | `exp(1)` | `2.718282` | - -#### Logarithmes - -Il n'y a pas de `ln()` dans `R`, mais on utilise `log()` pour désigner le logarithme naturel. `log10()` désigne le logarithme en base 10 - -| Math | code `R` | Résultat | -|:------------:|:---------------:|:-----------------:| -| $\ln(e)$ | `log(exp(1))` | `1` | -| $\log_{10}(1000)$ | `log10(1000)` | `3` | - -#### Trigonometrie - -| Math | code `R` | Résultat | -|:------------:|:---------------:|:-----------------:| -| $\sin(\pi / 2)$ | `sin(pi / 2)` | `1` | -| $\cos(0)$ | `cos(0)` | `1` | - - ---- - -## Objets - -Pour conserver le résultat d'une opération, on peut le stocker dans un objet à l'aide de l'opérateur d'assignation `<-`. Cette “flèche” stocke ce qu'il y a à sa droite dans un objet dont le nom est indiqué à sa gauche. - -```{r} -x <- 2 -``` -Se lit “prend la valeur 2 et mets la dans un objet qui s'appelle `x`”. - --- -Si on exécute une commande comportant juste le nom d'un objet, `R` affiche son contenu - -```{r} -x -``` --- - -On peut évidemment réutiliser cet objet dans d'autres opérations : `R` le remplacera alors par sa valeur. -```{r} -x+4 -``` - ---- -On peut créer autant d'objets qu'on le souhaite. - -```{r} -x <- 2 -y <- 5 -resultat <- x + y -resultat -``` --- - -Si on assigne une nouvelle valeur à un objet, la valeur précédente est perdue. - -```{r} -x <- 2 -x <- 5 -x -``` --- -Assigner un objet à un autre copie juste la valeur de l'objet de droite dans celui de gauche - -```{r} -x <- 1 -y <- 3 -x <- y -x -``` - ---- - -Les objets peuvent contenir tout un tas d'informations. - -Jusqu'ici on n'a stocké que des nombres, mais ils peuvent aussi contenir des chaînes de caractères (du texte), qu'on délimite avec des guillemets simples ou doubles (' ou ") : - -```{r} -chien <- "Chihuahua" -chien -``` - --- - -Ou encore des conditions logiques (`TRUE` ou `FALSE`) basées sur des comparaisons - -```{r} -valeur <- TRUE -valeur - -chien == "Doberman" -3<2 -``` - ---- -### Opérateurs logiques - -| Opérateur | Résumé | Exemple | Résultat | -|:---------|:---------------------:|:---------------------:|:-------:| -| `x < y` | `x` plus petit que `y` | `3 < 42` | `r 3 < 42` | -| `x > y` | `x` plus grand que `y` | `3 > 42` | `r 3 > 42` | -| `x <= y` | `x` plus petit ou égal à `y` | `3 <= 42` | `r 3 <= 42` | -| `x >= y` | `x` plus grand ou égal à `y` | `3 >= 42` | `r 3 >= 42` | -| `x == y` | `x` égal à `y` | `3 == 42` | `r 3 == 42` | -| `x != y` | `x` pas égal à `y` | `3 != 42` | `r 3 != 42` | -| `!x` | pas `x` | `!(3 > 42)` | `r !(3 > 42)` | -| x | y | `x` ou `y` | (3 > 42) | TRUE | `r TRUE` | -| `x & y` | `x` et `y` | `(3 < 4) & ( 42 > 13)` | `r (3 < 4) & ( 42 > 13)` | - - - ---- - -## Vecteurs - -Imaginons qu'on a demandé la taille en centimètres de 5 personnes et qu'on souhaite calculer leur taille moyenne. - -On pourrait créer autant d'objets que de tailles et calculer la moyenne - -```{r} -taille1 <- 156 -taille2 <- 164 -taille3 <- 197 -taille4 <- 147 -taille5 <- 173 -(taille1 + taille2 + taille3 + taille4 + taille5) / 5 -``` - --- -Ce n’est clairement pas pratique du tout. On va plutôt stocker l'ensemble de nos tailles dans un seul objet, un vecteur, avec la syntaxe suivante : - -```{r} -tailles <- c(156, 164, 197, 147, 173) -``` - -où le `c()` veut dire "combine les valeurs suivantes dans un vecteur ou une liste" - ---- -Si on affiche le contenu de cet objet, on voit qu’il contient bien l’ensemble des tailles saisies. - -```{r} -tailles -``` - --- -Si on applique une opération à un vecteur, celle-ci s'applique à toutes les valeurs qu'il contient. - -Si on veut la taille en mètres plutôt qu'en centimètres, on peut faire : -```{r} -tailles_m <- tailles/100 -tailles_m -``` - ---- -Imaginons maintenant qu’on a aussi demandé aux cinq mêmes personnes leur poids en kilos. - -On peut créer un deuxième vecteur : - -```{r} -poids <- c(45, 59, 110, 44, 88) -``` - -On peut alors effectuer des calculs utilisant nos deux vecteurs `tailles` et `poids`. - -On peut par exemple calculer l’indice de masse corporelle (IMC) de chacun de nos enquêtés en divisant leur poids en kilo par leur taille en mètre au carré : -```{r} -imc <- poids / (tailles / 100) ^ 2 -imc -``` - ---- - -Un vecteur peut contenir des nombres, mais il peut aussi contenir du texte. - -Imaginons qu'on a demandé aux 5 mêmes personnes leur type de chien préféré : on peut regrouper l'information dans un vecteur. - -```{r} -chiens_pref <-c("Doberman","Chihuahua","Husky","Bouvier Bernois","Labrador") -chiens_pref -``` - --- -Notons qu'on peut tester l'égalité des éléments d'un vecteur et d'un objet - -```{r} -chiens_pref==chien -tailles==147 -tailles_m>1.6 -``` - - - ---- - -L'opérateur `:` permet de générer rapidement un vecteur comprenant tous les nombres entre deux valeurs, opération assez courante sous R : - -```{r} -liste <- 1:10 -liste - -liste2 <- 10:1 -liste2 -``` - --- - -Si nous voulons créer une séquence qui ne soit pas limitée aux nombres entiers et qui augmente de 1 à la fois, nous pouvons utiliser la fonction `seq()`. -```{r} -seq(from = 1.5, to = 2.2, by = 0.1) -``` - ---- -### Sous vecteurs - -Pour extraire un sous-vecteur (subsetting), c'est-à-dire pour n'en choisir que certains éléments, nous utilisons des crochets, “`[]`”. Par exemple, `x[1]` renvoie le premier élément du vecteur `x`, et `x[3]` renvoie le troisième élément - -```{r} -tailles -tailles[1] -tailles[3] -``` - --- - -Nous pouvons également exclure certains indices, en les faisant précéder par un signe `-` . -```{r} -tailles[-2] -``` - ---- - -Enfin, on peut faire des sous-ensembles sur la base d'un vecteur d'indices. - -```{r} -tailles[1:3] -tailles[c(1,3,4)] -``` - - -Nous pourrions également utiliser un vecteur de valeurs logiques. - -```{r} -z = c(TRUE, TRUE, FALSE, TRUE, FALSE) -tailles[z] - -``` - -Ce qui est très pratique pour extraire un sous-vecteur des entrées respectant une condition logique : -```{r} -tailles[tailles>160] -``` ---- - -## Bases de données - -Dans R, les bases de données sont des `data.frame`. Dans une `data.frame`, chaque .red[variable] est stockée comme une colonne, et chaque ligne est une .red[observation]. - -Pour créer une `data.frame`, on utilise la commande `data.frame()` : -```{r} -base <- data.frame(tailles, poids) -``` - -Il est possible d'avoir plusieurs bases de données ouvertes simultanément dans une session R. Pour se référer à une variable particulière d'une base, on utilise la syntaxe `$` - -```{r} -mean(base$tailles) -range(base$poids) -``` - -Si on veut ajouter une variable à une base de données, on utilise la même syntaxe - -```{r} -base$imc <- base$poids/(base$taille/100)^2 -``` - - ---- - -## Fonctions - -### Principes - -Nous savons effectuer des opérations de base sur des nombres et des vecteurs, et stocker des valeurs dans des objets pour pouvoir les réutiliser plus tard. - -Pour aller plus loin, nous devons aborder les fonctions qui sont, avec les objets, un deuxième concept de base de R. On utilise des fonctions pour effectuer des calculs, obtenir des résultats et accomplir des actions. - -Formellement, une fonction a un nom, elle prend en entrée entre parenthèses un ou plusieurs arguments (ou paramètres), et retourne un résultat. - -Prenons tout de suite un exemple. Si on veut connaître le nombre d'éléments du vecteur `tailles` que nous avons construit précédemment, on peut utiliser la fonction `length()`, de cette manière : -```{r} -length(tailles) -``` - ---- - -Ici, `length()` est la fonction, on l'appelle en lui passant un argument entre parenthèses (ici notre vecteur tailles), et elle nous renvoie un résultat, à savoir le nombre d'éléments du vecteur passé en paramètre. - -Autre exemple, les fonctions `min()` et `max()` retournent respectivement les valeurs minimales et maximales d’un vecteur de nombres. - -```{r} -min(tailles) -max(tailles) -``` -La fonction `mean()` calcule et retourne la moyenne d'un vecteur de nombres. - -```{r} -mean(tailles) -``` - -Une fonction peut renvoyer d'autres types de résultats. Par exemple, la fonction `range()` (étendue) renvoie un vecteur de deux nombres, le minimum et le maximum. - -```{r} -range(tailles) -``` - ---- - -### Arguments - -Une fonction peut prendre plusieurs arguments, dans ce cas on les indique entre parenthèses en les séparant par des virgules. - -On a déjà rencontré un exemple de fonction acceptant plusieurs arguments : la fonction `c()`, qui combine l'ensemble de ses arguments en un vecteur -```{r} -tailles=c(156,164,197,147,173) -``` -Ici, `c()` est appelée en lui passant cinq arguments, les cinq tailles séparées par des virgules, et elle renvoie un vecteur numérique regroupant ces cinq valeurs. - -Supposons maintenant que dans notre vecteur tailles nous avons une valeur manquante (une personne a refusé de répondre, ou notre mètre mesureur était en panne). On symbolise celle-ci dans R avec le code interne `NA`. - -```{r} -tailles <- c(156, 164, 197, NA, 173) -tailles -``` - ---- - -### Valeurs manquantes - -Si on calcule maintenant la taille moyenne à l'aide de la fonction `mean()`, on obtient : -```{r} -mean(tailles) - -``` - -En effet, R considère par défaut qu’il ne peut pas calculer la moyenne si une des valeurs n’est pas disponible. Dans ce cas il considère que la moyenne est elle-même “non disponible” et renvoie donc `NA` comme résultat. - -On peut cependant indiquer à `mean()` d'effectuer le calcul en ignorant les valeurs manquantes. Ceci se fait en ajoutant un argument supplémentaire, nommé `na.rm` (abbréviation de NA remove, “enlever les NA”), et de lui attribuer la valeur `TRUE`. - -```{r} -mean(tailles, na.rm = TRUE) -``` - -Mettre le paramètre `na.rm` à `TRUE` indique à la fonction `mean()` de ne pas tenir compte des valeurs manquantes dans le calcul. - - ---- - -### Aide sur une fonction - -Il est fréquent de ne pas savoir (ou d'avoir oublié) quels sont les arguments d'une fonction, ou comment ils se nomment. On peut à tout moment faire appel à l'aide intégrée à R en passant le nom de la fonction (entre guillemets) à la fonction `help()`. -```{r eval=FALSE} -help("mean") -``` - -On peut aussi utiliser le raccourci `?mean`. - -```{r eval=FALSE} -?mean -``` - - -Ces deux commandes affichent une page (en anglais) décrivant la fonction, ses paramètres, son résultat, le tout accompagné de diverses notes, références et exemples. Ces pages d'aide contiennent à peu près tout ce que vous pourrez chercher à savoir, mais elles ne sont pas toujours d'une lecture aisée. - ---- - -### Regrouper ses commandes dans des scripts - -- Jusqu'ici on a utilisé R de manière “interactive”, en saisissant des commandes directement dans la console. Ce n'est pas très pratique pour sauvegarder son travail. De lorsque R ou RStudio redémarre, tout ce qui a été effectué dans la console est perdu. - - -- On va plutôt regrouper les commandes dans des scripts (de simples fichiers texte), qui vont garder une trace de toutes les opérations effectuées. En rouvrant les scripts et en réexécutant les commandes qu'ils contiennent on pourra “reproduire” le chargement des données, leur traitement, les analyses et leurs résultats. - -- Pour créer un script, il suffit de sélectionner le menu File, puis New file et R script. Une quatrième zone apparaît alors en haut à gauche de l'interface de RStudio. On peut enregistrer notre script à tout moment dans un fichier avec l'extension .R, en cliquant sur l'icône de disquette ou en choisissant File puis Save. - -- Un script est un fichier texte brut, qui s'édite de la manière habituelle. À la différence de la console, quand on appuie sur Entrée, cela n'exécute pas la commande en cours mais insère un saut de ligne. - - -- Pour exécuter une commande dans un script, il faut positionner le curseur sur la ligne de la commande en question, et de cliquer sur le bouton Run dans la barre d'outils juste au-dessus de la zone d'édition du script. On peut aussi utiliser le raccourci clavier Ctrl + Entrée (Cmd + Entrée sous Mac). On peut aussi sélectionner plusieurs lignes avec la souris ou le clavier et cliquer sur Run (ou utiliser le raccourci clavier), et l'ensemble des lignes est exécuté d'un coup. - ---- - -Au final, un script pourra ressembler à quelque chose comme ça : - -```{r eval = FALSE} -tailles <- c(156, 164, 197, 147, 173) -poids <- c(45, 59, 110, 44, 88) - -mean(tailles) -mean(poids) - -imc <- poids / (tailles / 100) ^ 2 -min(imc) -max(imc) - -``` - ---- -### Commentaires - -Les commentaires sont un élément très important d'un script. Il s'agit de texte, ignoré par R, et qui permet de décrire les étapes du script, sa logique, les raisons pour lesquelles on a procédé de telle ou telle manière… Il est primordial de documenter ses scripts avec des commentaires, car il est très facile de ne plus se retrouver dans un programme qu'on a produit soi-même, même après une courte interruption. - -Pour ajouter un commentaire, il suffit de le faire précéder d'un ou plusieurs symboles `#`. En effet, dès que R rencontre ce caractère, il ignore tout ce qui se trouve derrière, jussqu'à la fin de la ligne. - -On peut donc documenter le script précédent : - -```{r eval=FALSE} -# Saisie des tailles et poids des enquêtés -tailles <- c(156, 164, 197, 147, 173) -poids <- c(45, 59, 110, 44, 88) - -# Calcul des tailles et poids moyens -mean(tailles) -mean(poids) - -# Calcul de l'IMC (poids en kilo divisé par les tailles en mètre au carré) -imc <- poids / (tailles / 100) ^ 2 -# Valeurs extrêmes de l'IMC -min(imc) -max(imc) -``` - ---- - -## Installer et charger des extensions (packages) - -- L'installation de base de R permet de faire énormément de choses, mais le langage dispose en plus d'un système d'extensions permettant d'ajouter facilement de nouvelles fonctionnalités. La plupart des extensions sont développées et maintenues par la communauté des utilisateurs et utilisatrices de R, et diffusées via un réseau de serveurs nommé CRAN (Comprehensive R Archive Network). - -- Pour installer une extension, si on dispose d'une connexion Internet, on peut - - Cliquer sur le bouton Install de l'onglet Packages de RStudio. - - Il suffit alors d'indiquer le nom de l'extension dans le champ Package et de cliquer sur Install. - -- On peut aussi installer des extensions en utilisant la fonction `install.packages()` directement dans la console. Par exemple, pour installer le package `ggplot2` on peut exécuter la commande - -```{r eval=FALSE} -install.packages(ggplot2) -``` ---- - -- Une fois l'extension installée, il faut la “charger” avant de pouvoir utiliser les fonctions qu'elle propose. Ceci se fait avec la fonction `library()`. Par exemple, pour pouvoir utiliser les fonctions de `ggplot2`, vous devrez exécuter la commande suivante : - -```{r eval=FALSE} -library(ggplot2) -``` - -Ainsi, on regroupe en général en début de script toute une série de commandes `library()` qui permettent de charger tous les packages utilisés dans le script. Quelque chose comme - -```{r} -library(ggplot2) -library(haven) -library(tidyr) -``` - ---- -## Exercices - -###Exercice 1 - -Construire le vecteur x suivant : - -```{r echo=F} -x <- c(120, 134, 256, 12) -x -``` - -Utiliser ce vecteur x pour générer les deux vecteurs suivants : -```{r echo=F} -x+100 -x*2 -``` - ---- - -### Exercice 2 - -On a demandé à 4 ménages le revenu des deux conjoints, et le nombre de personnes du ménage : - -```{r} -conjoint1 <- c(1200, 1180, 1750, 2100) -conjoint2 <- c(1450, 1870, 1690, 0) -nb_personnes <- c(4, 2, 3, 2) -``` - -Calculer le revenu total de chaque ménage, puis diviser par le nombre de personnes pour obtenir le revenu par personne de chaque ménage. - --- - -### Exercice 3 - -Dans l'exercice précédent, calculer le revenu minimum et maximum parmi ceux du premier conjoint. -```{r} -conjoint1 <- c(1200, 1180, 1750, 2100) -``` - -Recommencer avec les revenus suivants, parmi lesquels l'un des enquêtés n'a pas voulu répondre : - -```{r} -conjoint1 <- c(1200, 1180, 1750, NA) -``` - ---- -### Exercice 4 - -Les deux vecteurs suivants représentent les précipitations (en mm) et la température (en °C) moyennes pour chaque mois de l'année pour la ville de Lyon (moyennes calculées sur la période 1981-2010) : - -```{r} -temperature <- c(3.4, 4.8, 8.4, 11.4, 15.8, 19.4, 22.2, 21.6, 17.6, 13.4, 7.6, 4.4) -precipitations <- c(47.2, 44.1, 50.4, 74.9, 90.8, 75.6, 63.7, 62, 87.5, 98.6, 81.9, 55.2) -``` - -Calculer la température moyenne sur l’année. - -Calculer la quantité totale de précipitations sur l’année. - -À quoi correspond et comment peut-on interpréter le résultat de la fonction suivante ? Vous pouvez vous aider de la page d’aide de la fonction si nécessaire. - -```{r} -cumsum(precipitations) -``` - -Même question pour : -```{r} -diff(temperature) -``` - ---- -### Exercice 5 - -On a relevé les notes en maths, anglais et sport d'une classe de 6 élèves et on a stocké ces données dans trois vecteurs : - -```{r} -maths <- c(12, 16, 8, 18, 6, 10) -anglais <- c(14, 9, 13, 15, 17, 11) -sport <- c(18, 11, 14, 10, 8, 12) -``` - -Calculer la moyenne des élèves de la classe en anglais. - -Calculer la moyenne générale de chaque élève (la moyenne des ses notes dans les trois matières). - - -Essayez de comprendre le résultat des deux fonctions suivantes (vous pouvez vous aider de la page d’aide de ces fonctions) : -```{r} -pmin(maths, anglais, sport) -pmax(maths, anglais, sport) -``` - - ---- -class: inverse - -# Premier travail avec les données - ---- -class: left, top - -## Données d'exemple - -Nous utiliserons dans ce cours des données issues de l'INSEE : la base "[Histoires de vie 2003](https://www.insee.fr/fr/statistiques/2532244)" - -La base est disponible au format `.csv` à l'adresse suivante [https://raw.githubusercontent.com/P8EcoGe/rl3/main/bases/hdv3.csv](https://raw.githubusercontent.com/P8EcoGe/rl3/main/bases/hdv3.csv) - -Vous pouvez la charger directement dans `R` à l'aide de la commande `read.csv()`. On va la placer dans un objet nommé `hv3` : - -```{r} -hv3 <- read.csv("https://raw.githubusercontent.com/P8EcoGe/rl3/main/bases/hdv3.csv") -``` - -Alternativement, vous pouvez enregistrer le fichier sur votre disque dur, puis le charger dans `R` avec - -```{r eval=FALSE} -hv3 <- read.csv("chemin_vers_le_fichier/hdv3.csv") -``` - -Vous pouvez voir dans l'onglet "Environment" que la base de donnée comprend 2000 observations, et 21 variables - - -Si vous souhaitez voir le contenu de la base, vous pouvez utiliser la commande `View()` : -```{r eval=FALSE} -View(hv3) -``` - - ---- - -## Structure de la base - -Un tableau étant un objet comme un autre, on peut lui appliquer des fonctions. Par exemple, `nrow()` et `ncol()` retournent le nombre de lignes et de colonnes du tableau. `dim()` renvoie les deux - -```{r} -nrow(hv3) -ncol(hv3) -dim(hv3) -``` - -La fonction `names()` retourne les noms des colonnes du tableau, c'est-à-dire la liste de nos variables - -```{r} -names(hv3) -``` - ---- -Enfin, la fonction `str()` renvoie un descriptif plus détaillé de la structure du tableau. Elle liste les différentes variables, indique leur type et affiche les premières valeurs. - -```{r} -str(hv3) -``` - ---- - -## Accéder aux variables, et en créer de nouvelles - -On se réfère aux variables à l'aide de l'opérateur `$`, qui permet d'accéder aux colonnes du tableau. On utilisera la syntaxe `nom_de_la_base$nom_de_la_variable` pour désigner une variable particulière d'une base de données. - -Par exemple, on peut utiliser la fonction `head()` pour afficher les premières valeurs de la variable `age` de la base stockée dans l'objet `hv3` - -```{r} -head(hv3$age) -``` - -On peut aussi utiliser l’opérateur `$` pour créer une nouvelle variable dans notre base : pour cela, il suffit de lui assigner une valeur. - -Par exemple, la variable `heures.tv` contient le nombre d'heures passées quotidiennement devant la télé. - -```{r} -head(hv3$heures.tv) -``` - ---- -On peut vouloir créer une nouvelle variable dans notre tableau qui contienne la même durée convertie en minutes. - -On va donc créer une nouvelle variables `minutes.tv` de la manière suivante - -```{r} -hv3$minutes.tv <- hv3$heures.tv * 60 -``` - -On peut alors constater, qu'une nouvelle variable (une nouvelle colonne) a bien été ajoutée à la base de données. - -```{r} -head(hv3$minutes.tv) -``` - ---- -## Analyse univariée - -### Variable quantitative - -Une variable quantitative est une variable de type numérique (un nombre) qui peut prendre un grand nombre de valeurs. On en a plusieurs dans notre jeu de données, notamment l'âge (variable `age`) ou le nombre d'heures passées devant la télé (`heures.tv`). - - -#### Indicateurs numériques -Pour obtenir un résumé numérique concis d'une variable numérique, on peut utiliser la commande `summary()` : - -```{r} -summary(hv3$heures.tv) -summary(hv3$age) -``` - -`summary()` donne le minimum, le maximum, la moyenne, les premier second (médiane) et troisième quartile de la distribution. La dernière valeur donne, s'il y en a, le nombre de valeurs manquantes (`NA`) pour la variable. - - - ---- - -On peut également obtenir (et, si on le souhaite, sauver dans un objet) les valeurs de chaque élément avec les fonction `min()`, `max()`, `median()`, `mean()` et `quantile()` : - -```{r} -min(hv3$age) -max(hv3$age) -mean(hv3$age) -median(hv3$age) -quantile(hv3$age,prob=0.75) # l'option "Prob=" permet de préciser le quantile souhaité -``` - ---- - -Si la variable examinée contient des valeurs manquante, il convient d'inclure l'option `na.rm=TRUE` dans l'appel de la fonction : - -```{r} -mean(hv3$heures.tv) -mean(hv3$heures.tv, na.rm=TRUE) -``` - -On peut obtenir des indicateurs de dispersion (variance, écart-type) à l'aide des commandes `var()` et `sd()` : - - - -```{r} -var(hv3$age) -sd(hv3$age) -``` - ---- - -#### Représentation graphique - -La représentation graphique la plus courante pour présenter la distribution d'une variable quantitative continue est l'histogramme, que l'on obtient à l'aide de la commande `hist()` - -.pull-left[ -```{r code-first, fig.show="hide", warning=FALSE} -hist(hv3$age) -``` -] - -.pull-right[ -```{r, echo=FALSE,out.width = '400px'} -knitr::include_graphics( - knitr::fig_chunk("code-first", "png") -) -``` -] - ---- - -.pull-left[ -```{r code-second, fig.show="hide", warning=FALSE} -hist(hv3$age, breaks=10) -``` -] - -.pull-right[ -```{r, echo=FALSE,out.width = '300px'} -knitr::include_graphics( - knitr::fig_chunk("code-second", "png") -) -``` -] - -.pull-left[ -```{r code-trois, fig.show="hide", warning=FALSE} -hist(hv3$age, col = "skyblue", - main = "Répartition des âges des enquêtés", - xlab = "Âge", - ylab = "Effectif", - breaks = 30) -``` -] - -.pull-right[ -```{r, echo=FALSE,out.width = '300px'} -knitr::include_graphics( - knitr::fig_chunk("code-trois", "png") -) -``` -] ---- -Une autre représentation classique est la "Boîte à moustache", que l'on obtient avec la commande `boxplot()` : - -.pull-left[ -```{r box1, fig.show="hide", warning=FALSE} -boxplot(hv3$age) -``` -] - -.pull-right[ -```{r, echo=FALSE,out.width = '250px'} -knitr::include_graphics( - knitr::fig_chunk("box1", "png") -) -``` -] - -.pull-left[ -```{r box2, fig.show="hide", warning=FALSE} -boxplot(hv3$age~hv3$sport, # La syntaxe y~x permet de représenter la distribution de y pour chaque valeur de x - col=c("gold","darkgreen"), - xlab="Pratique d'un sport", ylab="Âge" - ) -``` -] - -.pull-right[ -```{r, echo=FALSE,out.width = '250px'} -knitr::include_graphics( - knitr::fig_chunk("box2", "png") -) -``` -] - - diff --git a/style_perso.css b/style_perso.css deleted file mode 100644 index 7b73e6b..0000000 --- a/style_perso.css +++ /dev/null @@ -1,18 +0,0 @@ -.remark-inline-code{ - background-color: whitesmoke - } -.full { - padding: 0px; - } - -.remark-slide-content { - padding-top: 10px; - padding-left: 10px; - padding-right: 10px; - padding-bottom: 10px; - } -.remark-slide-content > h1:first-of-type { - margin-top: 0px; - } - -.red { color: red; } \ No newline at end of file diff --git a/templace_files/figure-html/cars-1.svg b/templace_files/figure-html/cars-1.svg deleted file mode 100644 index 55fc692..0000000 --- a/templace_files/figure-html/cars-1.svg +++ /dev/null @@ -1,193 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -