Introduction à R

École interdisciplinaire outils & méthodes (EIOM)
Midi-métho

Jules Piral

24 août 2026

Plan

1. Introduction à R
2. Les applications de R dans la recherche
3. Pourquoi utiliser R en recherche ?
4. Exemple pratique
5. R et intelligence artificielle
6. Le rôle du chercheur à l’Ère de l’IA

Annoncer d’emblée la limite : “On ne sortira pas d’ici en sachant coder en R.” L’objectif est de rendre R moins intimidant et de donner envie de l’essayer. Transition vers 1.1 : “Commençons par comprendre ce qu’est R.”

1. Introduction à R

1.1 R : Langage et environnement logiciel libre

• Permets d’analyser, transformer et visualiser des données

• Libre et gratuit, développé et maintenu par la R Core Team

• Un écosystème extensible grâce aux packages

• Packages spécialisés = répondre facilement à des tâches spécifiques

• 24752 packages sur CRAN (Comprehensive R Archive Network)

• GitHub héberge également de nombreux packages et projets R

Insister sur “libre et gratuit” — c’est souvent la première question. Contrairement à SPSS ou Stata, personne ne peut décider demain de mettre R derrière un paywall. Pour les 24 752 packages : “Peu importe ce que vous voulez faire, quelqu’un l’a probablement déjà fait et packagé.” Transition : “Mais qu’est-ce que ça veut dire concrètement d’utiliser R ?”

1.2 R : Une calculatrice

mean(c(1, 2, 3)) → 2

«Calculatrice» → R peut effectuer des calculs complexes.

«Feuille de papier» → Permets d’écrire toutes les étapes du raisonnement et de les conserver.

«Automate» → R peut exécuter automatiquement les étapes.

L’analogie “calculatrice” démystifie : R ne fait rien de magique, juste des calculs. mean(c(1, 2, 3)) donne 2 — pas sorcier. La feuille de papier : chaque étape est écrite noir sur blanc, contrairement à un clic dans un menu qu’on ne peut pas retrouver. L’automate : c’est ce qui rend R puissant — répéter automatiquement toutes ces étapes. Question à poser : “Qui a déjà fait un calcul dans Excel qu’il ne pouvait plus reproduire 6 mois plus tard ?”

1.3 Le code comme trace de l’analyse

Une commande est une instruction du langage R.

Les commandes sont inscrites dans le code, chaque opération laisse une trace.

La combinaison de commandes forme un script.

Un script est ainsi reproductible, versionnable, auditable.

L’idée clé : le code est une trace écrite du raisonnement. “Reproductible” = quelqu’un d’autre peut faire tourner ton script et obtenir le même résultat. “Versionnable” = tu peux revenir en arrière dans l’historique. “Auditable” = quelqu’un peut vérifier exactement ce que tu as fait à tes données. Contrairement à un clic dans Excel, ça laisse une trace.

1.4 Positron et RStudio: Environnements de développement

Positron

Montrer les 4 zones de l’interface : éditeur (haut gauche, où on écrit le script), console (bas gauche, où R exécute), environnement (haut droit, les objets en mémoire), fichiers/graphiques (bas droit). Positron est recommandé — plus récent, meilleure intégration IA, activement développé. RStudio reste très répandu dans les tutoriels et la littérature, donc les deux noms reviendront souvent.

1.5 Comprendre la logique de R : objets, fonctions et scripts

• Objet : ce que R garde en mémoire (x <- 5)
• Fonction : une action sur des objets (mean(x))
• Script : une suite d’instructions reproductible

Ces quatre briques permettent de lire n’importe quel code R basique. Mini-démo en live si le temps le permet : x <- 5 crée un objet, mean(x) applique une fonction, x <- x * 2 fait une transformation, un script enchaîne tout ça. “Tout ce que vous verrez en R est une combinaison de ces quatre éléments.” Transition : “Maintenant qu’on sait ce qu’est R, voyons à quoi ça sert en recherche.”

2. Les applications de R dans la recherche

2.1 Importer et structurer les données

Depuis n’importe quel format

• CSV
• Excel
• SPSS
• JSON
• TXT
• etc.

Premier obstacle en pratique. Fonctions clés : read_csv() pour les CSV, read_excel() pour Excel, haven::read_sav() pour SPSS. L’avantage : le chemin vers le fichier est inscrit dans le code — pas de “j’ai copié-collé depuis je ne sais plus où”. Transition : “Une fois importées, les données sont rarement prêtes à analyser.”

2.2 Nettoyer, transformer et préparer les données

Data cleaning & Data wrangling

• Renommer, filtrer, réordonner, joindre, agréger
• Traiter les valeurs manquantes
• Changer la forme des tableaux

C’est ici que se passe la majorité du travail réel — on le quantifiera à la slide 4.4. dplyr (dans le tidyverse) couvre l’essentiel : filter(), select(), mutate(), group_by(), summarise(). Les valeurs manquantes (NA) sont un sujet à part entière : R les gère explicitement, ce qui force à prendre des décisions conscientes plutôt que de les ignorer silencieusement comme Excel.

2.3 Explorer les données

• Statistiques descriptives
• Distributions
• Corrélations
• Anomalies

Avant d’analyser, on regarde. head(), summary(), hist(), table(). L’objectif : développer une intuition sur les données avant de les modéliser. Les anomalies détectées ici — valeurs impossibles, distributions asymétriques, catégories mal encodées — évitent des erreurs coûteuses plus tard. Même ggplot2 sert l’exploration, pas seulement la communication finale.

2.4 Analyser les données

• Régressions (linéaires, logistiques, ordinales, etc.)
• Données longitudinales et modèles multiniveaux
• Méthodes causales (expériences, diff-in-diff, variables instrumentales)
• Analyse de réseaux sociaux
• Analyses factorielles et modèles de variables latentes

Tout est accessible via les packages CRAN.

Le message : peu importe la méthode statistique, il y a un package. Régression linéaire (lm()), logistique (glm()), multiniveaux (lme4), bayésien (brms), réseaux (igraph), etc. Les étudiants n’ont pas à réinventer la roue — ils doivent comprendre la méthode pour bien utiliser le package et interpréter les résultats.

2.5 Visualiser les données

Data visualization

ggplot2 : package permettant de construire n’importe quel graphique.

ggplot2 est une des raisons majeures pour lesquelles R domine en communication scientifique. La logique est en couches : données → axes → forme (barres, points, lignes) → couleurs → labels → thème. On le verra en détail à la section 4. Transition : “On a vu ce que R peut faire — voyons maintenant pourquoi ça vaut la peine de l’apprendre en recherche.”

2.6 Automatiser, reproduire et documenter son travail

• Gagner en rapidité
• Rejouer un pipeline entier en une commande
• Traiter 1 000 fichiers avec le même script
• Chaque analyse laisse une trace, soit le script.

Le gain de productivité n’est pas immédiat — le premier script prend du temps. Mais une fois écrit, tu rejoues en une commande. Exemples concrets : traiter les données de 50 participants avec le même pipeline, refaire toute une analyse quand de nouvelles données arrivent, ou mettre à jour un rapport annuel en changeant juste le fichier source. “Un script écrit une fois peut tourner 100 fois.”

3. Pourquoi utiliser R en recherche ?

3.1 Développer une meilleure compréhension de ses données

• Explorer les données
• Décrire leurs caractéristiques
• Identifier les incohérences
• Comparer les observations et les groupes
• Tester différentes transformations
• Questionner les résultats

R rend le “jeu” avec les données rapide et réversible. Exemple : tu veux tester si retirer les valeurs aberrantes change tes résultats ? Deux lignes de code, et tu peux comparer les deux versions. Sous Excel, c’est une demi-journée et tu perds le fil. C’est cette agilité qui construit une vraie compréhension empirique.

3.2 Garder le contrôle sur ses analyses

• Rendre explicites les transformations
• Comprendre ce qui se passe derrière les résultats
• Pouvoir revenir sur ses décisions méthodologiques

L’exemple clé : un clic dans Excel est perdu — un script, non. Si tu veux revenir sur une décision prise il y a 6 mois (changer un seuil de découpage, exclure une observation, corriger un recodage), tu modifies une ligne et tu relances. Tout le reste se recalcule automatiquement. “Le script est une mémoire externe de ton raisonnement.”

3.3 Améliorer la reproductibilité

Un script c’est une analyse qui peut être reproduite à l’identique.

library(tidyverse)          # dépendances déclarées explicitement

df_bingo <- read_csv("racj-licence-bingo.csv")   # source de données explicite

df_bingo %>% count(Ville, sort = TRUE)           # même résultat à chaque fois

Lire les trois lignes à voix haute et commenter chaque commentaire. library(tidyverse) : les dépendances sont déclarées — n’importe qui sait quoi installer. read_csv("fichier.csv") : la source est explicite — pas de copier-coller invisible. count(Ville, sort = TRUE) : le même script tourne sur n’importe quel ordinateur et donne le même résultat. Ces trois habitudes suffisent à rendre un projet reproductible.

4. Exemple pratique

4.1 Partir d’une question de recherche

Où concentre-t-on les salles de bingo au Québec ?

Poser le cadre avant de lancer la démo : “Je vais faire en direct ce qu’on vient de décrire. On part d’une question, on importe des données publiques, on les transforme, on produit un graphique.” RACJ = Régie des alcools, des courses et des jeux. Données de licences de bingo actives, disponibles sur données.québec.ca. Insister : c’est le chercheur qui formule la question — R l’exécute.

4.2 Importer les données

# Charger le package tidyverse (inclut readr, dplyr, ggplot2…)
library(tidyverse)

# Lire le CSV de https://www.donneesquebec.ca/recherche/dataset/racj-licence-bingo
df_bingo <- read_csv("racj-licence-bingo.csv")

df_bingo est maintenant un objet en mémoire : un tableau (data frame).

Ouvrir Positron. Montrer le fichier CSV dans l’explorateur de fichiers avant de le charger. library(tidyverse) charge readr, dplyr et ggplot2 d’un coup — expliquer ça en passant. Après read_csv(), pointer le panneau Environnement : df_bingo y apparaît avec ses dimensions. “R confirme que l’objet est en mémoire.” Si readr affiche un message sur les types de colonnes, montrer que c’est normal et informatif, pas une erreur.

4.3 Explorer la structure et le contenu des données importées

head(df_bingo)      # premières lignes

str(df_bingo)       # types de colonnes

summary(df_bingo)   # statistiques descriptives

Lancer les trois commandes l’une après l’autre et commenter en direct. head() : “On voit les premières lignes — quelles colonnes, quels types de valeurs.” str() : “On voit les types — character, numeric, date — et si quelque chose est mal encodé.” summary() : “Min, max, médiane — les premières anomalies apparaissent souvent ici.” Insister : “C’est le premier réflexe à avoir, avant de faire quoi que ce soit d’autre.”

4.4 Nettoyer et transformer les données

df_top10 <- df_bingo %>%
  count(Ville, sort = TRUE) %>%   # compter les licences par ville
  slice_max(n, n = 10)            # garder le top 10

df_top10   # vérifier le résultat

Expliquer le pipe %>% : “ça se lit ‘et puis’. Prends df_bingo, et puis compte par ville, et puis garde le top 10.” Recadrer les attentes : dans un vrai projet, ~70% du travail est ici — avant même d’arriver à l’analyse ou à la visualisation. Les données du RACJ sont relativement propres, donc on s’en tire bien aujourd’hui. Montrer df_top10 dans la console pour vérifier le résultat avant de passer à la suite.

4.5 Visualiser les résultats (le code)

ggplot(df_top10, aes(x = n,
                     y = reorder(Ville, n),   # trie les villes par n croissant
                     fill = n)) +             # couleurs proportionnelle aux salles
  geom_col() +                                # une barre horizontale par ville
  geom_text(aes(label = n), hjust = -0.2, size = 3.5) + # valeurs numériques au bout
  scale_fill_gradient(low = "#e8f5e9",
                      high = "#1b5e20") +   # couleurs des colonnes
  scale_x_continuous(expand = expansion(mult = c(0, 0.1)), # ajustement de la marge
                     breaks = seq(0, 150, by = 10)) + # gradation axe des x
  labs(
    title = "Top 10 des villes avec le plus de salles de bingo au Québec", # titre
    x = "Nombre de salles",                   # ajoute titre axe des x
    y = NULL                                  # enlève titre axe des y
  ) +
  theme_minimal(base_size = 15) +
  theme(
    legend.position = "none",                 # suppression de la légende
    panel.grid.major.y = element_blank(),     # grille horizontale supprimée
    panel.grid.minor.x = element_blank()      # grille entre la gradation supprimée
  )

Lire le code à voix haute couche par couche : “On dit à ggplot quelles données utiliser et sur quels axes. On ajoute des barres (geom_col). On trie par valeur (reorder). On ajoute les étiquettes (geom_text). On choisit les couleurs (scale_fill_gradient). On nomme les axes (labs). On nettoie le fond (theme_minimal).” La logique est additive — chaque + ajoute une couche, qu’on peut retirer ou modifier indépendamment.

4.6 Visualiser les résultats (le graphique)

Laisser un silence quand le graphique apparaît — c’est le moment “wow”. Souligner : ce graphique est directement publiable, couleurs cohérentes, mise en page propre, titre informatif. Tout ça en une vingtaine de lignes de code. Conclure la démo : “Si on reçoit de nouvelles données demain, on remplace le CSV et on relance — le graphique se met à jour automatiquement.” Transition : “R est aussi très bien adapté au travail avec l’IA.”

5. R et intelligence artificielle

5.1 L’IA comme assistant de programmation

• Générer du code
• Expliquer du code
• Corriger des erreurs
• Proposer des approches alternatives

Introduire la section : “Maintenant qu’on sait ce que R peut faire, parlons de comment l’IA change l’apprentissage et la pratique de R.” Les quatre usages : générer (écrire le code à ta place), expliquer (décortiquer ce que fait un bout de code), corriger (déboguer une erreur), proposer (suggérer une autre approche). Exemples : Claude ou ChatGPT pour écrire un ggplot, GitHub Copilot pour corriger une erreur de syntaxe.

5.2 L’IA permet d’aplatir la courbe d’apprentissage

• Pas besoin de mémoriser toute la syntaxe
• Permets de poser une question en langage naturel
• Apprendre au fur et à mesure de ses besoins

Reconnaître ouvertement ce que beaucoup font déjà : demander à ChatGPT de leur écrire le code. C’est légitime. L’IA aplatit la courbe d’apprentissage — plus besoin de mémoriser toute la syntaxe pour commencer à produire des résultats. Mais ça crée un nouveau risque, qu’on va aborder à la slide suivante. Ne pas être moralisateur ici — juste nommer la réalité.

5.3 Pourquoi comprendre R reste essentiel

• Savoir formuler de bonnes demandes à l’IA (avoir les intuitions)
• Comprendre ce que fait le code généré
• Identifier les erreurs ou mauvaises interprétations
• Comprendre les structures de données et leurs conséquences
• Rester maître des décisions scientifiques

Le pivot de la section. Insister sur le dernier bullet : “rester maître des décisions scientifiques.” Exemple concret : si l’IA te propose df %>% drop_na() pour enlever toutes les lignes avec des valeurs manquantes, tu dois pouvoir évaluer si c’est approprié dans ton contexte — peut-être que ces NA sont informatifs, ou concentrés sur un sous-groupe. Sans compréhension du code, tu ne peux pas poser cette question. Message clé : “L’IA génère, tu valides.”

5.4 Mais l’IA peut aussi avoir de « bonnes intuitions »

• Elle propose parfois des solutions pertinentes
• Elle identifie des problèmes auxquels le chercheur n’a pas pensé
• Elle peut dépasser les connaissances immédiates du chercheur

Mais le traitement des données est lui-même un choix méthodologique. L’IA peut proposer des options, mais c’est au chercheur d’en évaluer les implications et de choisir.

Nuancer pour ne pas sonner anti-IA. L’IA propose parfois des solutions auxquelles on n’aurait pas pensé — c’est une vraie valeur ajoutée. Mais la différence entre un utilisateur passif et un chercheur, c’est la capacité d’évaluer ces propositions. “Ce n’est pas une délégation, c’est un dialogue.” Le dernier paragraphe de la slide est le message à marteler avant de passer à la section 6.

6. Le rôle du chercheur à l’ère de l’IA

6.1 Les données : partie intégrante du processus scientfique

Les données ne sont jamais entièrement neutres ou « brutes ».

Leur structure et leur traitement façonnent les résultats.

Choisir une variable, une agrégation, un seuil, c’est un choix scientifique.

Transition épistémologique importante. Les données ne tombent pas du ciel — elles sont construites. Exemples à donner : mesurer le “revenu” comme brut ou net, c’est déjà un choix théorique. Grouper par ville vs par région, c’est un choix analytique. Décider qu’une valeur est “aberrante” et la retirer, c’est un choix scientifique. R rend ces choix explicites dans le code — ce qui est une bonne chose pour l’auditabilité.

6.2 « Jouer » avec ses données pour mieux les comprendre

• Explorer
• Transformer
• Tester
• Comparer
• Questionner

L’IA peut brouiller ces étapes. Savoir lire et comprendre le code est donc essentiel.

Le “jeu” ici n’est pas frivole — c’est le moteur de la compréhension empirique. Attention avec l’IA : si tu délègues l’exploration à l’IA sans lire le code, tu obtiens des résultats sans comprendre comment tu y es arrivé. Tu ne développes pas d’intuition sur tes données. C’est là que savoir lire le code devient critique — même si c’est l’IA qui l’a écrit.

6.3 Garder la maîtrise de son analyse par la lecture du code

• Comprendre ce qui est fait aux données
• Décider & Comprendre les choix méthodologiques
• Vérifier la cohérence du processus

Le script comme preuve du raisonnement. Tendance croissante : les revues demandent le code et les données en matériel supplémentaire. Savoir lire son propre code, c’est savoir défendre ses choix méthodologiques lors d’une révision ou d’une soutenance. Un article sans code est moins auditable qu’un article avec.

6.4 Ce qui demeure du ressort du chercheur

• Définir la question
• Définir ce que représentent les données
• Faire les choix méthodologiques
• Évaluer la plausibilité des résultats
• Interpréter et contextualiser

La slide de synthèse — prendre le temps de lire chaque point lentement. Ces cinq activités ne sont pas automatisables. Définir la question : c’est la théorie. Définir ce que représentent les données : c’est la mesure. Faire les choix méthodologiques : c’est le design. Évaluer la plausibilité : c’est le jugement. Interpréter et contextualiser : c’est la contribution. “C’est là que réside votre valeur ajoutée en tant que chercheur.”

Conclusion

L’objectif n’est pas de remplacer le chercheur par l’IA, mais de lui permettre de gagner du temps sur les tâches techniques.

L’IA permets au chercheur de se concentrer sur ce qui est le plus important : la question de recherche, la théorie et les choix méthodologiques.

Pour aller plus loin : Datacamp · capsules du CAPP.

Lire les deux phrases lentement, marquer un silence à la fin. Remercier et ouvrir les questions. Rappeler la dispo pour l’installation de R et Positron. Mentionner Datacamp et les capsules du CAPP comme ressources autonomes. Si des questions émergent sur du code spécifique, proposer de rester après pour regarder ensemble.