R Academy · Leçon

map2() et pmap() pour plusieurs entrées

Parcourez simultanément deux listes ou plus avec map2() et pmap().

map2() et pmap() pour plusieurs entrées est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Itérer sur plusieurs entrées

map() itère sur une seule entrée à la fois. Or de nombreuses fonctions nécessitent deux entrées parallèles ou davantage. map2() de purrr gère deux entrées ; pmap() en gère un nombre quelconque. Toutes deux garantissent une valeur de retour du même type, de manière sûre.

library(purrr)

# Simulate: add corresponding elements from two vectors
x <- c(1, 2, 3, 4)
y <- c(10, 20, 30, 40)

# map2 applies fn(x[i], y[i]) for each i
result <- map2(x, y, function(a, b) a + b)
print(result)

map2() — Deux entrées parallèles

map2(.x, .y, .f) applique .f(x_i, y_i) aux éléments correspondants de .x et .y. Les deux vecteurs doivent avoir la même longueur (ou l’un d’eux doit avoir une longueur de 1 et être recyclé). La fonction renvoie une liste.

library(purrr)

names_vec <- c('Alice','Bob','Carol')
scores_vec <- c(85, 92, 78)

# Build a personalized message for each student
map2_chr(names_vec, scores_vec,
         ~paste(.x, 'scored', .y, 'points'))

map2() avec la notation abrégée ~

La notation sous forme de formule ~expr fonctionne avec map2() : .x désigne la première entrée et .y la deuxième. Cela permet de garder concises les fonctions anonymes à deux arguments.

library(purrr)

lower_bounds <- c(0, 10, 20, 50)
upper_bounds <- c(9, 19, 49, 100)

# Create labels for each range
map2_chr(lower_bounds, upper_bounds,
         ~paste0('[', .x, '-', .y, ']'))

Variantes typées de map2()

Comme map(), map2() possède des variantes typées qui garantissent le type de retour : map2_dbl(), map2_chr(), map2_lgl(), map2_int() et map2_df(). Utilisez la variante correspondant au type de sortie attendu.

library(purrr)

actual <- c(100, 150, 200, 120)
target <- c(110, 140, 195, 130)

# Numeric: percentage achievement
map2_dbl(actual, target, ~round(100 * .x / .y, 1))

# Logical: did they meet their target?
map2_lgl(actual, target, ~.x >= .y)

pmap() — Un nombre quelconque d’entrées

pmap(.l, .f) prend une liste de vecteurs comme premier argument. Chaque vecteur constitue un flux d’entrée distinct. La fonction reçoit simultanément les éléments correspondants de tous les flux d’entrée.

library(purrr)

# Three parallel inputs
params <- list(
  name = c('Alice','Bob','Carol'),
  score = c(85, 92, 78),
  grade = c('B','A','C')
)

pmap_chr(params, function(name, score, grade) {
  paste(name, ':', score, '(', grade, ')')
})

pmap() avec un cadre de données

Un cadre de données est une liste de colonnes — vous pouvez donc transmettre directement un cadre de données comme premier argument à pmap(). La fonction reçoit les valeurs d’une ligne sous forme d’arguments nommés, en associant les noms de colonnes aux noms des paramètres.

library(purrr)

params_df <- data.frame(
  mean_val = c(0, 5, 10),
  sd_val = c(1, 2, 3),
  n = c(100, 50, 200)
)

# Generate samples from different normal distributions
set.seed(42)
results <- pmap(params_df, function(mean_val, sd_val, n) {
  rnorm(n, mean=mean_val, sd=sd_val)
})

map_dbl(results, mean)

Itérer sur des grilles de paramètres

Une utilisation courante de pmap() consiste à parcourir une grille de paramètres de modèle. Utilisez expand.grid() ou tidyr::expand_grid() pour créer les combinaisons de paramètres, puis pmap() pour exécuter l’expérience sur chaque ligne.

library(purrr)

# Create a parameter grid
grid <- expand.grid(
  learning_rate = c(0.01, 0.1),
  epochs = c(10, 50),
  batch_size = c(32, 64)
)

# Simulate model training results
set.seed(42)
grid$accuracy <- pmap_dbl(grid, function(learning_rate, epochs, batch_size) {
  base <- 0.5 + 0.3 * log10(epochs) + 0.1 * learning_rate
  round(min(base + rnorm(1, 0, 0.02), 0.99), 3)
})

print(grid[order(-grid$accuracy),])

map2_df() — Construire des cadres de données

map2_df() (ou map2_dfr()) applique une fonction à deux entrées parallèles et empile par lignes les cadres de données obtenus. Cette approche est très utile pour comparer deux ensembles d’éléments ou fusionner des jeux de données parallèles.

library(purrr)

q1_sales <- list(East=100, West=200, North=80)
q2_sales <- list(East=120, West=190, North=95)

map2_df(q1_sales, q2_sales, function(q1, q2) {
  data.frame(
    q1 = q1,
    q2 = q2,
    change = q2 - q1,
    pct = round(100*(q2-q1)/q1, 1)
  )
}, .id = 'region')

Combiner pmap() et nest()

Associer pmap() à des cadres de données imbriqués et à des paramètres de modèle permet d’utiliser un schéma puissant : stockez les hyperparamètres et les données dans un même cadre de données, puis utilisez pmap() sur les lignes afin d’ajuster des modèles avec chaque ensemble de paramètres.

library(purrr)
library(dplyr)

# Simulate polynomial regression with different degrees
set.seed(42)
x <- 1:20
y <- 2*x + 0.5*x^2 + rnorm(20, 0, 10)
df <- data.frame(x=x, y=y)

configs <- data.frame(degree = 1:3)
configs$r2 <- map_dbl(configs$degree, function(d) {
  m <- lm(y ~ poly(x, d), data=df)
  summary(m)$r.squared
})

print(configs)

Gérer les erreurs avec possibly()

Dans les traitements utilisant map2()/pmap(), une seule entrée incorrecte peut faire échouer toute l’opération. Encadrez votre fonction avec possibly(fn, otherwise=NA) pour intercepter les erreurs et renvoyer une valeur par défaut, afin de maintenir le pipeline en fonctionnement même lorsque certaines entrées échouent.

library(purrr)

safe_log <- possibly(log, otherwise=NA_real_)

values <- list(10, -5, 100, 0, 50)

# Without possibly(): log() warns for negative numbers
# With possibly(): errors return NA, computation continues
map_dbl(values, safe_log)

En pratique : validation croisée avec pmap()

Une application pratique de pmap() consiste à effectuer une validation croisée en k parties en parcourant les affectations des parties. pmap() transmet à la fonction d’ajustement les données d’entraînement et de test de chaque partie, puis renvoie une mesure de performance par partie.

library(purrr)

set.seed(42)
df <- data.frame(x=1:20, y=2*(1:20)+rnorm(20,0,3))
df$fold <- sample(rep(1:5, 4))

# Compute RMSE for each held-out fold
folds <- 1:5
rmse_vals <- map_dbl(folds, function(k) {
  train <- df[df$fold != k, ]
  test <- df[df$fold == k, ]
  m <- lm(y ~ x, data=train)
  preds <- predict(m, newdata=test)
  sqrt(mean((test$y - preds)^2))
})

cat('Per-fold RMSE:', round(rmse_vals, 2), '\n')
cat('Mean RMSE:', round(mean(rmse_vals), 2))

Vérification rapide

Quelle fonction de purrr convient pour itérer simultanément sur plus de deux vecteurs d’entrée parallèles ?

Récapitulatif : map2() et pmap()

Points essentiels concernant le parcours de plusieurs entrées :

map2(.x, .y, .f) — itère sur deux entrées parallèles ; .x et .y sont utilisés dans la notation abrégée ~
map2_dbl/chr/lgl/int/df() — variantes typées garantissant le type de retour
pmap(.l, .f) — itère simultanément sur une liste contenant un nombre quelconque de vecteurs
Transmettez un cadre de données à pmap() — les noms de colonnes deviennent les noms des paramètres de la fonction
Utilisez expand.grid() + pmap() pour explorer une grille de paramètres
Encadrez les fonctions avec possibly(fn, NA) pour gérer les erreurs de manière sûre

library(purrr)

# pmap with a data frame: each row = one function call
params <- data.frame(
  mean_val = c(0, 10, 100),
  sd_val = c(1, 5, 20),
  label = c('control','mid','high')
)

pmap_chr(params, function(mean_val, sd_val, label) {
  sprintf('%s: mean=%.0f, sd=%.0f', label, mean_val, sd_val)
})

Questions Fréquemment Posées

La leçon « map2() et pmap() pour plusieurs entrées » est-elle gratuite ?

Oui — le texte complet de « map2() et pmap() pour plusieurs entrées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « map2() et pmap() pour plusieurs entrées » ?

Parcourez simultanément deux listes ou plus avec map2() et pmap(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « map2() et pmap() pour plusieurs entrées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à R Academy