Séance 7 : Automatisation et rapports

Apprendre R avec les LLMs

Auteur·rice

Elias Bouacida

Date de publication

14 octobre 2025

Plan de la séance

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

Production attendue : Rapport automatisé fonctionnel au format PDF/HTML

Objectifs de la séance

Automatiser pour gagner du temps

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

Retours sur l’organisation

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 :

Vous avez analysé les ventes de janvier…

Maintenant on vous demande d’analyser janvier, février, mars, avril, mai, juin… 📊

Problème

Copier-coller votre code 12 fois ? Non ! Il faut automatiser.

Traitement par lots

Principe de l’automatisation

Au lieu de :

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 :

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

Demandez au LLM :

“Comment lister tous les fichiers CSV d’un dossier en R ?”

Vous découvrirez :

# 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)

Testez avec vos propres fichiers !

15 minutes. Première étape de l’automatisation.

Exercice 2 : Boucle sur des fichiers

Créez un script qui traite plusieurs fichiers :

# 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)

20 minutes. Pattern essentiel pour l’automatisation.

Exercice 3 : Fonction d’analyse par lots

Créez une fonction réutilisable :

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/")

25 minutes. Fonction professionnelle d’automatisation.

Gestion des erreurs dans les boucles

Problème : Un fichier corrompu plante tout !

# 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
  })
}

Demandez au LLM d’expliquer tryCatch() !

Introduction à R Markdown

Qu’est-ce que R Markdown ?

R Markdown permet de créer des documents qui mélangent :

Du texte (explications, interprétations)
Du code R (analyses)
Des résultats (tableaux, graphiques)
Des formules mathématiques

Formats de sortie :

PDF, HTML, Word
Présentations (comme ce cours !)
Sites web, livres

Pourquoi R Markdown ?

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

Important

Si vos données changent, votre rapport se met à jour automatiquement !

Structure d’un document R Markdown

Un fichier .Rmd contient :

---
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

Créez un nouveau fichier R Markdown :

Dans RStudio : File > New File > R Markdown
Donnez un titre et choisissez HTML
Cliquez sur “Knit” pour générer le document

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é

Demandez au LLM :

“Explique-moi la syntaxe de base de Markdown (titres, listes, gras, italique)”

20 minutes. Première découverte de R Markdown.

Options des blocs de code

On peut contrôler ce qui apparaît dans le rapport :

```{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")
```

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

Créez un rapport R Markdown qui :

Importe un jeu de données
Affiche les premières lignes (avec head())
Calcule des statistiques (moyenne, médiane, etc.)
Crée 2 graphiques
Interprète les résultats en texte

Structure suggérée :

# 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...

30 minutes. Premier rapport complet.

Markdown pour le formatage

Syntaxe de base :

# 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)

Demandez au LLM de vous montrer plus d’options de formatage !

Rapport paramétré

Pourquoi paramétrer ?

Problème : Vous voulez le même rapport pour différents datasets

Solution : Créer un template paramétrable

---
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 :**


````{.default}
---
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 :**


::: {.cell}

```{.r .cell-code}
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 :**


::: {.cell}

```{.r .cell-code}
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
---

Pour générer un format spécifique :

render("rapport.Rmd", output_format = "pdf_document")

Mini-projet : Système de rapports

Projet final : Rapports automatisés

Objectif : Créer un système complet de génération de rapports

Spécifications :

Un template R Markdown paramétrable
Une fonction qui génère des rapports pour plusieurs fichiers
Les rapports doivent inclure :
- Import et nettoyage automatique
- Statistiques descriptives
- Au moins 3 graphiques
- Interprétation textuelle
Gestion des erreurs (fichiers manquants, colonnes manquantes)
Génération en HTML

Utilisez tout ce que vous avez appris

Fonctions, dplyr, ggplot2, gestion d’erreurs, R Markdown !

65 minutes. Projet de synthèse final.

Critères du projet

✅ 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

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

Exercice réflexif : Journal de bord

Documentez :

Automatisation :
- Comment automatiser un traitement répétitif ?
- Votre fonction d’analyse par lots
- Une erreur que vous avez gérée avec tryCatch()
R Markdown :
- Différences avec un script R normal
- Avantages pour vos analyses
- Options de blocs de code les plus utiles
Rapports paramétrés :
- Votre template réutilisable
- Comment vous allez l’utiliser à l’avenir
- Difficultés rencontrées et solutions

15 minutes. Documentation des apprentissages avancés.

Ce que vous avez accompli

✅ 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

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

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

Devoirs

Finalisez votre système de rapports automatisés
Testez-le avec au moins 3 fichiers différents
Mettez à jour votre journal en détail
Préparez-vous pour le projet collaboratif final
Réfléchissez aux bonnes pratiques pour travailler en équipe sur du code

Séance finale : Projet collaboratif - intégrer vos compétences en équipe !

Questions ?

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 !

Bravo pour ces compétences avancées ! 🎓