{"id":899,"date":"2018-02-13T15:26:54","date_gmt":"2018-02-13T14:26:54","guid":{"rendered":"http:\/\/perso.ens-lyon.fr\/lise.vaudor\/?p=899"},"modified":"2018-03-21T11:23:25","modified_gmt":"2018-03-21T10:23:25","slug":"iterer-des-fonctions-avec-purrr","status":"publish","type":"post","link":"https:\/\/perso.ens-lyon.fr\/lise.vaudor\/iterer-des-fonctions-avec-purrr\/","title":{"rendered":"It\u00e9ration de fonctions avec purrr"},"content":{"rendered":"

\"\"<\/p>\n

Bon, les amis, je vais \u00eatre abrupte, mais voil\u00e0:<\/p>\n

Les boucles sont officiellement has been<\/em> depuis le printemps-\u00e9t\u00e9 2017. Non, je ne parle pas des boucles soyeuses et joyeuses qui s’\u00e9battent sur vos t\u00eates (pour les plus chanceux d’entre vous). Je veux parler des boucles laborieuses et \u00e9pineuses qui s’\u00e9tirent sur vos scripts.<\/p>\n

Alors, je me sens quand-m\u00eame l\u00e9g\u00e8rement g\u00ean\u00e9e de vous annoncer cela vu que, peut-\u00eatre, vous avez r\u00e9cemment appris \u00e0 faire des boucles et vous vous en trouvez fort aise (moi aussi, je me souviens, quand j’ai fait mes premi\u00e8res boucles, de la joie, de la fiert\u00e9 \u00e9prouv\u00e9e, de la conviction vibrante que j’allais d\u00e9sormais dire adieu aux assommantes t\u00e2ches r\u00e9p\u00e9titives). Peut-\u00eatre que mentionner la ringardise des boucles devant des gens qui apprennent \u00e0 utiliser R, c’est comme annoncer \u00e0 un ado tout fier des ses trois premiers poils de moustache que bon, c’est pas tr\u00e8s joli et qu’il va falloir raser tout \u00e7a. Je pr\u00e9cise donc, au cas o\u00f9 cette id\u00e9e vous d\u00e9moralise trop, qu’un peu de ringardise n’a jamais fait de mal \u00e0 personne et que vous pouvez choisir de voir vos bonnes vieilles boucles for de derri\u00e8re les fagots comme une touche \u00ab\u00a0vintage\u00a0\u00bb dans vos scripts (et nous ne sommes pas l\u00e0 pour juger!).<\/p>\n

Concr\u00e8tement, la boucle for n’a pas le vent en poupe pour plusieurs raisons: elle est assez longue \u00e0 \u00e9crire, elle peut donner lieu \u00e0 pas mal d’erreurs (elle est \u00ab\u00a0error-prone\u00a0\u00bb, comme diraient les anglophones), et elle n’est pas tr\u00e8s efficace en termes de calcul (ce dernier argument pouvant rev\u00eatir une importance plus ou moins av\u00e9r\u00e9e selon que vos scripts sont calculatoirement gourmands ou non).<\/p>\n

Notez aussi que, non contentes de remplacer les boucles for, les fonctions de purrr<\/code> sont aussi susceptibles de remplacer dans vos scripts les fonctions apply()<\/code>, tapply()<\/code>, sapply()<\/code> et consorts…<\/p>\n

Mais venons-en au fait, \u00e0 savoir ce qui est cens\u00e9 remplacer les boucles for<\/em> (parce que quand-m\u00eame, savoir it\u00e9rer une t\u00e2che, une routine, un script, \u00e7a reste un must), \u00e0 savoir, les fonctions du package purrr<\/strong>.<\/p>\n

\"\"<\/p>\n

Principe g\u00e9n\u00e9ral<\/h1>\n

purrr<\/strong>, c’est un package du tidyverse<\/strong> (qui compte d’autres packages ultra-connus et appr\u00e9ci\u00e9s comme dplyr, ggplot2, lubridate, etc.) qui sert \u00e0 it\u00e9rer des fonctions<\/strong>. C’est une package qui s’inscrit un peu dans la logique de la programmation fonctionnelle, c’est-\u00e0-dire dans l’id\u00e9e que tout ce qui arrive<\/em> dans R est le r\u00e9sultat d’un appel \u00e0 une fonction (alors que ce qui existe<\/em> dans R est un objet). Pour rendre \u00e0 C\u00e9sar ce qui revient \u00e0 C\u00e9sar, je reprends l\u00e0 les mots de John Chambers: \u201cTo understand computations in R, two slogans are helpful: Everything that exists is an object. Everything that happens is a function call.\u00a0\u00bb.<\/p>\n

Fonctions: inputs, output, side effects<\/h1>\n

Voil\u00e0 comment on peut voir une fonction…<\/p>\n

\"\"<\/p>\n

… comme une petite usine qui transforme ses mati\u00e8res premi\u00e8res (les inputs<\/strong>, ou arguments) en produits finis (les outputs<\/strong>), en g\u00e9n\u00e9rant parfois au passage des effets \u00ab\u00a0immat\u00e9riels\u00a0\u00bb -c’est-\u00e0-dire autres que des objets- ici repr\u00e9sent\u00e9s par de la fum\u00e9e (les side effects<\/strong>).<\/p>\n

Ici je consid\u00e8re une fonction .f()<\/code> qui a un input principal x<\/code> et des inputs secondaires (...<\/code>). Classiquement, on va produire l’output en appelant la fonction avec pour arguments l’input x<\/code> et les inputs secondaires: output=.f(x,...)<\/code>.<\/p>\n

Par exemple:<\/p>\n

x=c(33,NA,2,15,7,4,5)\nmoyenne=mean(x,na.rm=TRUE)\n<\/code><\/pre>\n
Ici, j’ai produit l’output moyenne<\/code> en appelant la fonction mean()<\/code>, avec pour argument principal x<\/code> et pour argument secondaire na.rm=TRUE<\/code>.<\/p>\n
It\u00e9ration: map(), walk()<\/h1>\n
Imaginons maintenant que je souhaite appeler la fonction mean()<\/code> de mani\u00e8re r\u00e9p\u00e9t\u00e9e sur plusieurs \u00e9l\u00e9ments d’une liste:<\/p>\n
myX=list(c(33,NA,2,15,7,4,5),\n         c(22,1,3,NA,11,2),\n         c(1,5),\n         c(3),\n         c(12,5,9))\n<\/code><\/pre>\n
Je pourrais choisir de le faire via une boucle for \u00ab\u00a0vintage\u00a0\u00bb:<\/p>\n
moyennes=vector(\"list\",length=5)\nfor (i in 1:length(myX)){\n  moyennes[i]=mean(myX[[i]],na.rm=TRUE)\n}\nprint(moyennes)\n\n## [[1]]\n## [1] 11\n## \n## [[2]]\n## [1] 7.8\n## \n## [[3]]\n## [1] 3\n## \n## [[4]]\n## [1] 3\n## \n## [[5]]\n## [1] 8.666667\n<\/code><\/pre>\n
OU BIEN je peux choisir de le faire avec la fonction map()<\/code> du package purrr<\/code><\/p>\n
library(purrr)\nmoyennes=map(myX,mean, na.rm=TRUE)\nprint(moyennes)\n\n## [[1]]\n## [1] 11\n## \n## [[2]]\n## [1] 7.8\n## \n## [[3]]\n## [1] 3\n## \n## [[4]]\n## [1] 3\n## \n## [[5]]\n## [1] 8.666667\n<\/code><\/pre>\n
Ainsi, en utilisant map()<\/code>, j’ai en quelque sorte transform\u00e9 ma petite fonction\/usine mean()<\/code> en lui adjoignant une \u00ab\u00a0rampe d’approvisionnement\u00a0\u00bb<\/strong>:<\/p>\n
\"\"<\/p>\n
Mon argument principal, x<\/code>, devient ainsi une liste<\/strong> d’\u00e9l\u00e9ments utilis\u00e9s comme input pour la fonction mean()<\/code>. Mon argument secondaire, na.rm=TRUE<\/code>, est en revanche le m\u00eame pour toutes les it\u00e9rations.<\/p>\n
L’output \u00ab\u00a0moyennes\u00a0\u00bb est par d\u00e9faut \u00e9galement une liste<\/strong>.<\/p>\n
Notez que l’on aurait pu ici demander explicitement \u00e0 ce que le r\u00e9sultat nous soit renvoy\u00e9 non pas comme une liste, mais comme un vecteur de valeurs num\u00e9riques de type \u00ab\u00a0double\u00a0\u00bb<\/strong>:<\/p>\n
moyennes=map_dbl(x,mean,na.rm=TRUE)\nprint(moyennes)\n\n## [1]  33 NaN   2  15   7   4   5\n<\/code><\/pre>\n
Selon le type d’output renvoy\u00e9 par la fonction, il peut ainsi \u00eatre assez pratique d’utiliser les fonctions map_dbl()<\/code> (double) map_lgl<\/code> (logique) map_int()<\/code> (entier), etc.<\/p>\n
Consid\u00e9rons maintenant les \u00ab\u00a0effets secondaires\u00a0\u00bb\u00a0\u00bb, en prenant pour exemple une fonction dont l’utilit\u00e9 premi\u00e8re n’est pas de renvoyer un output, mais plut\u00f4t d’afficher quelque chose dans la console:<\/p>\n
print_moyenne=function(x){\n  print(paste(\"la moyenne est de\",\n              mean(x,na.rm=TRUE)))\n  return(NULL)\n}\n<\/code><\/pre>\n
La fonction \u00ab\u00a0walk()\u00a0\u00bb permet d’it\u00e9rer les \u00ab\u00a0effets secondaires\u00a0\u00bb d’une fonction… ici 5 messages\/nuages de fum\u00e9e diff\u00e9rents:<\/p>\n
walk(x,print_moyenne)\n\n## [1] \"la moyenne est de 33\"\n## [1] \"la moyenne est de NaN\"\n## [1] \"la moyenne est de 2\"\n## [1] \"la moyenne est de 15\"\n## [1] \"la moyenne est de 7\"\n## [1] \"la moyenne est de 4\"\n## [1] \"la moyenne est de 5\"\n<\/code><\/pre>\n
2 arguments principaux: map2()<\/h1>\n
\"\"<\/p>\n
Consid\u00e9rons maintenant une fonction \u00e0 laquelle on voudrait adjoindre \u00ab\u00a0deux rampes d’approvisionnement\u00a0\u00bb:<\/p>\n
reg=function(x,y,w=rep(1,length(x))){\n  result=lm(y~x,weights=w)\n  return(result)\n}\n<\/code><\/pre>\n
Cette fonction reg()<\/code> r\u00e9alise une r\u00e9gression lin\u00e9aire de y en fonction de x (avec des poids uniformes, par d\u00e9faut) et renvoie l’objet \u00ab\u00a0r\u00e9gression lin\u00e9aire\u00a0\u00bb correspondant (l’output de reg()<\/code> est donc un objet \u00ab\u00a0composite\u00a0\u00bb de type liste).<\/p>\n
myX=list(c(2,5,6,7,1,0,1,1),\n       c(5,1,6,NA,2),\n       c(2,5,8,6))\nmyY=list(c(5,8,9,7,22,1,9,9),\n       c(2,8,9,5,4),\n       c(8,9,8,7))\n<\/code><\/pre>\n
On veut it\u00e9rer la fonction reg()<\/code> en consid\u00e9rant chaque \u00e9l\u00e9ment de x ET de y (le i-i\u00e8me \u00e9l\u00e9ment de x correspondant au i-i\u00e8me \u00e9l\u00e9ment de y…). On peut faire cela en consid\u00e9rant la fonction map2()<\/code>.<\/p>\n
map2(myX,myY,reg)\n\n## [[1]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##      9.2162      -0.1622  \n## \n## \n## [[2]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##     5.85294     -0.02941  \n## \n## \n## [[3]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##     8.28000     -0.05333\n<\/code><\/pre>\n
Notez ici que la fonction reg()<\/code> renvoie une liste donc ce n’est pas pertinent ici d’essayer d’utiliser une fonction de type map_xxx() (en l’\u00e9tat, le r\u00e9sultat de l’it\u00e9ration ne peut pas \u00eatre mis en forme comme un vecteur).<\/p>\n
p arguments principaux: pmap()<\/h1>\n
Enfin, on peut g\u00e9n\u00e9raliser ce principe \u00e0 p<\/em>\u2004>\u20042 arguments principaux:<\/p>\n
\"\"<\/p>\n
Dans ce cas, les p listes d’arguments sont fournis comme une liste, i.e. on passe \u00e0 pmap()<\/code> un argument .l<\/code> qui est une liste de p \u00e9l\u00e9ments<\/strong> qui sont eux-m\u00eames des listes<\/em>…<\/p>\n
Consid\u00e9rons par exemple un cas o\u00f9 l’on souhaite it\u00e9rer la fonction reg()<\/code>, consid\u00e9r\u00e9e pr\u00e9c\u00e9demment, mais cette fois-ci sur 3 arguments, \u00e0 savoir x, y, et w:<\/p>\n
myW=list(c(1,2,1,1,1,2,1,1),\n         c(2,1,1,1,1),\n         c(1,2,1,1))\n\npmap(list(x=myX,\n          y=myY,\n          w=myW),\n     reg)\n\n## [[1]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##      7.3805       0.1855  \n## \n## \n## [[2]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##       6.011       -0.266  \n## \n## \n## [[3]]\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##     8.53191     -0.06383\n<\/code><\/pre>\n
Echapper aux erreurs: safely()<\/code><\/h1>\n
Jusqu’ici, tout va bien: j’ai choisi pour commencer des exemples d’application simples, o\u00f9 tout se d\u00e9roule comme sur des roulettes.<\/p>\n
Mais avec les fonctions de purrr<\/code> comme avec une boucle for, il est particuli\u00e8rement probl\u00e9matique qu’une des it\u00e9rations g\u00e9n\u00e8re une erreur<\/strong>, car m\u00eame si cette erreur ne concerne qu’un \u00e9l\u00e9ment parmi peut-\u00eatre beaucoup d’autres, son occurrence stoppe l’ex\u00e9cution de toutes<\/em> les it\u00e9rations.<\/p>\n
Consid\u00e9rons ainsi l’exemple suivant:<\/p>\n
myX=list(c(2,5,6,7,1,0,1,1),\n         c(5,1,6,NA,2),\n         c())\nmyY=list(c(5,8,9,7,22,1,9,9),\n         c(2,8,9,5,4),\n         c())\nmap2(myX,myY,reg)\n\n## Error in model.frame.default(formula = y ~ x, weights = w, drop.unused.levels = TRUE): type (NULL) incorrect pour la variable 'y'\n<\/code><\/pre>\n
A\u00efe… La fonction reg n’accepte pas que ses arguments x ou y soient nuls et g\u00e9n\u00e8re ainsi une erreur sur la troisi\u00e8me it\u00e9ration. On n’obtient donc pas de r\u00e9sultat pour la troisi\u00e8me it\u00e9ration, ni, du reste, pour les autres…<\/p>\n
Pour rem\u00e9dier \u00e0 cela, outre modifier la fonction reg()<\/code> pour qu’elle puisse s’adapter \u00e0 ce cas particulier, il est possible d’utiliser la fonction safely()<\/code>:<\/p>\n
map2(myX,myY,safely(reg))\n\n## [[1]]\n## [[1]]$result\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##      9.2162      -0.1622  \n## \n## \n## [[1]]$error\n## NULL\n## \n## \n## [[2]]\n## [[2]]$result\n## \n## Call:\n## lm(formula = y ~ x, weights = w)\n## \n## Coefficients:\n## (Intercept)            x  \n##     5.85294     -0.02941  \n## \n## \n## [[2]]$error\n## NULL\n## \n## \n## [[3]]\n## [[3]]$result\n## NULL\n## \n## [[3]]$error\n## <simpleError in model.frame.default(formula = y ~ x, weights = w, drop.unused.levels = TRUE): type (NULL) incorrect pour la variable 'y'>\n<\/code><\/pre>\n
Dans ce cas, pour chaque \u00e9l\u00e9ment d’input, on obtient un \u00e9l\u00e9ment d’output qui contient deux choses:<\/p>\n