Plate-forme technologique SMCS

Transcription

1 Plate-forme technologique SMCS Midis du SMCS Toujours plus vite avec R! Auteur: Alain Guillet - SMCS - IMMAQ Date: Le 1er décembre 2009 Plate-forme technologique de Support en Méthodologie et Calcul Statistique, UCL - Voie du Roman Pays, 20 B-1348 Louvain-la-Neuve Tel: (32) Fax: (32)

2 Table des matières 1 Deviner ou mesurer? 2 2 La vectorisation Pourquoi vectoriser? La famille.apply mapply() et Vectorize() Les boucles Initialisation Dedans ou dehors? Parfois nécessaires! Optimiser Gagner du temps en utilisant des fonctions optimisées Programmant en C ou Fortran En résumé : la bonne pratique 12 6 A faire : parallélisation de la tâche 12 1

3 Introduction R est un langage très utilisé pour ses aptitudes à faire de la statistique et des graphiques personnalisables. Par contre, on oublie trop souvent que R est également un langage de programmation complet bien adapté à la programmation scientifique. Comme tout langage de programmation, une mauvaise utilisation de celui-ci, voire une méconnaissance des spécificités du langage, peuvent conduire à une très forte augmentation du temps de calcul. Cependant, il est inutile de passer des heures à essayer d optimiser un programme dont le bénéfice ne sera que de quelques secondes ou bien de casser un code qui fonctionnait en introduisant une erreur dedans. Les seuls cas pour lesquels l on devrait optimiser son programme sont : pour un package pour des simulations ou, plus généralement, pour un programme qui sera exécuté un grand nombre de fois Il y a trois règles à ne jamais oublier dans tout programme R : 1. Ne pas optimiser sauf en cas de réelle nécessité 2. Toujours commencer les programmes en effaçant tous les objets de l espace de travail :rm(list=ls()) 3. Vectoriser les expressions dès la première écriture 1 Deviner ou mesurer? Lorsque le temps de calcul d un programme semble long, il ne faut pas essayer d optimiser immédiatement le code en se disant que c est ici ou là qu est le problème. Tout d abord, on calcule le temps global à l aide de la fonction system.time(), puis on va utiliser la fonction Rprof() afin de déterminer quelle étape du programme ralentit l exécution. Cette seconde fonction peut aussi donner des informations sur l utilisation de la mémoire grâce à l option memory.profiling. > Rprof("tmp.out") > toto <- Vectorize(function(fn, n) system.time(fn(n)), vectorize.args = c("n")) > time1 <- function(n) { + a <- NULL + for (i in 1:n) a <- c(a, i^2) + return(a) > exemple1 <- toto(time1, seq(0, 5000, by = 1000)) > Rprof() Les packages proftools et profr permettent de résumer l information d un profilage d exécution de code afin de mieux comprendre ce qui se passe durant son exécution. Ci-dessous un exemple avec le package proftools : > library(proftools) > flatprofile(readprofiledata("tmp.out")) total.pct total.time self.pct self.time.call <Anonymous> do.call dotrycatch eval evalfunc

4 mapply Sweave system.time toto try trycatch trycatchlist trycatchone withvisible fn gc ^ > flatprofile(readprofiledata("tmp.out"), FALSE) self.pct cum.self.time self.time total.pct total.time gc fn ^ Call <Anonymous> do.call dotrycatch eval evalfunc mapply Sweave system.time toto try trycatch trycatchlist trycatchone withvisible La vectorisation 2.1 Pourquoi vectoriser? R est un langage interprété, i.e. le code est analysé, puis évalué lors de l exécution, il est alors plus efficace d écrire du code vectorisé (qui sera exécuté de manière vectorielle). De plus, il existe un grand nombre de fonctions vectorisées dans R :%*%,%o%,colsums(),colmeans(),... Cependant, comme nous le verrons un peu plus loin, les boucles ne sont pas nécessairement mauvaises (cf. la section 3 sur les boucles) 2.2 La famille.apply La famille.apply permet d appliquer une fonction, que l on a créée ou pas, à un objet de R de manière vectorielle : apply() à une matrice ou un array en choisissant une ou plusieurs dimensions sur lesquelles on appliquera la fonction lapply(),sapply() ettapply() à un vecteur, une liste ou un dataframe rapply() qui est unlapply() d un objet de la classe dendogram récursif dendrapply() qui s applique aux noeu 3

5 Par exemple, si l on veut trouver le maximum dans chacune des colonnes d une matrice, on pourra utiliser la fonction apply() en spécifiant la dimension sur laquelle on souhaite travailler (1 : lignes, 2 : colonnes, etc.) et en passant la fonctionmax comme argument : > A <- matrix(rnorm(12), ncol = 4) > A [,1] [,2] [,3] [,4] [1,] [2,] [3,] > apply(a, 2, max) [1] Ou encore, si l on veut extraire la deuxième colonne de deux matrices qui sont les deux éléments d une liste : > A <- matrix(1:4, ncol = 2) > B <- matrix(5:10, ncol = 3) > (L <- list(a, B)) [[1]] [,1] [,2] [1,] 1 3 [2,] 2 4 [[2]] [,1] [,2] [,3] [1,] [2,] > lapply(l, "[",, 1) [[1]] [1] 1 2 [[2]] [1] 5 6 > sapply(l, function(x) x[, 1]) [,1] [,2] [1,] 1 5 [2,] 2 6 Nous avons utilisé ici les fonctionslapply() qui crée en sortie une liste etsapply() qui a simplifié le résultat, d où le s. Il est à noter que nous aurions également pu utiliser la fonction rapply(). La sortie aurait alors été un vecteur. 2.3 mapply() et Vectorize() mapply() et Vectorize() permettent de passer des vecteurs d arguments à des fonctions qui normalement utilisent un seul argument comme la fonction integrate() de R qui permet de calculer une intégrale entre deux 4

6 Densité d'une normale N(0,1) y exp( x 2) π dx x FIGURE 1 Intégrer sur la fonction de densité d une normale N(0,1) bornes. Cependant, ces deux fonctions ne sont pas tout à fait équivalentes puisquevectorize est plus générale que mapply(). En effet, on peut mettre la fonction comme paramètre alors que la fonction est fixée une fois pour toute avecmapply(). Supposons qu on veuille calculer l aire en rouge sur le graphique 1, exp( x/2) 2π, on peut utiliser la fonction integrate() de R avec la fonction dnorm. On aurait pu utiliser la fonction pnorm() qui permet de calculer une probabilité pour une distribution normale mais nous ne pourrions alors plus utiliser les fonctions mapply() et Vectorize(). > integrate(dnorm, lower = -1.96, upper = 1.96) with absolute error < 1.0e-11 > pnorm(1.96) - pnorm(-1.96) [1] Imaginions maintenant que nous souhaitions calculer l intégrale de cette fonction entre et -3, -3 et -2, -2 et -1, -1 et 0, 0 et 1, 1 et 2, 2 et 3 et enfin 3 et +. On pourrait utiliser huit fois la fonctionintegrate() en changeant 5

7 les bornes d intégration mais nous allons plutôt utiliser la fonction mapply comme ci-dessous en définissant deux vecteurs de bornes : > lo <- c(-inf, -3:3) > up <- c(-3:3, Inf) > (P <- mapply(function(lo, up) integrate(dnorm, lo, up)$value, + lo, up)) [1] [7] > sum(p) [1] 1 La fonction mapply est suffisante tant que l on intègre sur la même fonction, comme dit plus haut, et a une syntaxe plus facile que la fonction Vectorize() pour laquelle le calcul se fait en deux étapes : dans un premier temps, on crée la fonctionintegrate(), puis on l applique àdnorm() et les vecteurs de bornes des intégrales. > Integrate <- Vectorize(function(fn, lower, upper) integrate(fn, + lower, upper)$value, vectorize.args = c("lower", "upper")) > Integrate(dnorm, lower = lo, upper = up) [1] [7] C est plus compliqué mais si on veut calculer l intégrale d une autre fonction, il suffira de prendre la fonction Integrate() définit comme ci-dessus et lui appliquer les nouveaux paramètres. 3 Les boucles Contrairement à ce qui a pu être compris dans ce qui a été dit précédemment, les boucles ne sont pas toujours mauvaises. Elles sont conseillées dans les cas ci-après : Quand il est difficile d écrire du code vectorisé Quand le code vectorisé utilise beaucoup de mémoire Les boucles sont plus efficaces que les appels récursifs dans R Par ailleurs, il ne faut pas éviter de construire une boucle pour le plaisir d éviter une boucle, au contraire, si la boucle semble être le meilleur moyen de programmer un morceau de code, il faut la faire.malgré tout, afin qu une boucle ne ralentisse pas un programme, il y a quelques règles à suivre : Initialiser les nouveaux objets à leur taille définitive avant la boucle plutôt qu augmenter leurs tailles dans la boucle sinon à chaque itération la mémoire doit être allouée et l objet copié Ne pas faire dans la boucle ce qui peut être fait en dehors (un calcul, vérifier une condition sur chaque élément, etc.) 3.1 Initialisation Dans l exemple suivant, on souhaite créer le vecteur a tel que i, a i = i 2. On le fait de trois manières : la première sans initialisation de a, la deuxième en initialisant a et la dernière de manière vectorielle, puis on calcule les temps d exécution des trois procédés de création. > # Sans initialisation > initialisation1 <- function(n){ + a <- NULL 6

8 + for(i in 1:n) a <- c(a,i^2) > # Avec initialisation > initialisation2 <- function(n){ + a <- numeric(n) + for(i in 1:n) a[i] <- i^2 > # Vectoriellement > initialisation3 <- function(n){ + a <- (1:n)^2 Temps utilisateur en 10 2 seconde Boucle sans initialisation Boucle avec initialisation Opération vectorielle sans boucle n FIGURE 2 Vectoriser si possible et toujours préallouer la mémoire Comme le montre la figure 2, cela vaut la peine de mesurer les temps de calcul car les temps peuvent être très différents (la préallocation de la mémoire permet d aller trente fois plus vite sur mon ordinateur). Le plus rapide est d utiliser une approche vectorielle (initialisation3()), ce qui n est pas une surprise de part la nature de R. La chose à retenir est que lorsqu une approche vectorielle est compliquée à mettre en oeuvre, il 7

9 faut alors ne pas oublier d initialiser les objets à leurs tailles maximales lors de leurs créations si on la connait. 3.2 Dedans ou dehors? Temps utilisateur en 10 2 seconde Calcul dans la boucle Calcul hors de la boucle Opération vectorielle sans boucle n FIGURE 3 Calculer hors des boucles L exemple sur lequel on s appuie ici est le calcul du vecteur a tel que a i = 2π sin(i). > # Calcul dans la boucle > dedansdehors1 <- function(n){ + a <- numeric(n) + for(i in 1:n) a[i] <- 2*pi*sin(i) + a > # Calcul hors de la boucle > dedansdehors2 <- function(n){ + a <- numeric(n) + for(i in 1:n) a[i] <- sin(i) + 2*pi*a 8

10 > # Vectoriellement > dedansdehors3 <- function(n){ + 2*pi*sin(1:n) Il faut retenir de ceci (figure 3) que les différences entre les temps de calcul ne sont pas forcément très élevées entre les fonctions dedansdehors1() et dedansdehors2() mais elles existent malgré tout et que leurs petitesses est imputable à la simplicité du calcul réalisé ici. 3.3 Parfois nécessaires! Une boucle est parfois nécessaire et pour le montrer, on s appuie ici sur une petite histoire qui est intervenue sur la mailing-list R-help et qui fut reprise par [3]. La question était la suivante : Soit matrices la liste de matrices définies ci-dessous. > matrices <- vector(mode = "list", length = 10000) > for (i in seq_along(matrices)) matrices[[i]] <- matrix(rnorm(100), + ncol = 10) Comment sommer le grand nombre de matrices contenues dans la liste matrices? Autrement dit, comment calculer S telle que (i, j) [1,10] 2, S(i, j) = où M k est la k ème matrice de la liste définie ci-dessus? k=1 M k (i, j), 1. La première réponse est la réponse naturelle en faisant une boucle dans laquelle on additionne deux matrices. Itérativement, on obtient le résultat souhaité. > S1 <- matrix(0,ncol=10,nrow=10) > for (M in matrices) + S1 <- S1+M 2. «Quoi? Une boucle? Ce ne peut pas être la bonne réponse!» Ici se trouvent deux propositions de calcul de la somme des matrices sur la liste sans utiliser de boucle. Je dois bien reconnaitre que c est quelque peu technique... Bonne réponse numéro 1 : > S2 <- apply(array(unlist(matrices), + dim=c(10,10,10000)),1:2,sum) Bonne réponse numéro 2 : > S3 <- rowsums(array(unlist(matrices), + dim=c(10,10,10000)),dims=2) Que faut-il en conclure? Comme on peut le voir sur le graphique 4, les trois méthodes ont des temps de calcul très proches les uns des autres. Mais il y a une chose que je n ai pas montré : il y a un problème de mémoire au-delà de n = 59 (sur mon ordinateur) pour les deux propositions utilisant un array au lieu de la boucle : Error: cannot allocate vector of size Mb 4 Optimiser Dans cette section, nous allons voir deux moyens pas complètement dans R d optimiser son code. Tout d abord en utilisant les fonctions du package gsl de R, puis en programmant en C (cela pourrait aussi être réalisé en fortran). 9

11 array + apply array + rowsums Boucle for Temps utilisateur en secondes Nombre de lignes de la matrice carrée FIGURE 4 La vitesse de calcul est plus ou moins la même 4.1 Gagner du temps en utilisant des fonctions optimisées Le package gsl est un wrapper pour la GNU Scientific Library (c est une bibliothèque libre écrite en C fournissant des outils de calculs numériques en mathématiques appliquées). Quelques-une des fonctions ont été interfacées pour R et sont donc utilisables comme une fonction de R sous réserve d installer le package gsl avant. Vous pouvez trouver plus d informations sur ce package sur le site du CRAN : http ://cran.r-project.org/web/packages/gsl/index.html. On peut aussi utiliser la bibliothèque BLAS pour Basic Linear Algebra Subprograms qui agit directement au niveau du processeur pour les opérations de base de l algèbre linéaire comme la multiplication de matrices ou de vecteurs. Elle permet donc un accroissement de la vitesse d exécution des calculs sur les vecteurs et les matrices en utilisant l architecture du processeur (cache optimisé, pipelines, etc.). Pour Windows, on utilise ATLAS (Automatically Tuned Linear Algebra) qui est un BLAS optimisé. Pour ce faire, il faut remplacer le fichier Rblas.dll se trouvant dans le répertoire bin de l installation de R par celui se trouvant sur le site du CRAN dans Windows, contrib, ATLAS. Attention, il faut prendre le fichier correspondant au processeur de votre ordinateur sans quoi R risque de moins bien fonctionner voire de ne plus fonctionner du tout. Sur mon ordinateur avec un processeur Core2Duo, il n y avait pas de différence. 10

12 4.2 Programmant en C ou Fortran On veut calculer la factorielle d un nombre n sans utiliser la fonctionfactorial() de R. Le code ci-dessous est une des multiples manières de le faire dans le langage de R : > factorieller <- function(n) { + if (n == 0) + factorielle <- 1 + else for (i in 1:n) { + factorielle <- factorielle * i + return(factorielle) Programme R Programme C Temps utilisateur en secondes e+00 2e+06 4e+06 6e+06 8e+06 1e+07 n Préalablement à l écriture du code C et avant de pouvoir appeler le code dans R, il faut installer Rtools : http :// et ajouter R, MinGW et Perl dans le chemin de l environnement des variables. Ensuite, il faut écrire le code dans un fichier : { void cfactorielle(double *data,double *factorielle) 11

13 int i; factorielle[0] = 1; for (i = 0; i < *data; i++){ factorielle[0] *= (i+1);} } } Puis on compile le code créé en exécutant R CMD SHLIB nom_fichierc. Il ne reste plus qu à écrire une fonction dans R qui appellera le code C compilé : > factoriellec <- function(data) { + if (!(is.loaded("cfactorielle"))) + dyn.load("factorielle.dll") +.C("cfactorielle", as.double(data), factorielle = double(1))$factorielle Sur cet exemple, le code C est dix fois plus rapide que le code R. Par contre, il est moins rapide que la fonction factorial() qui est déjà implémentée dans R. 5 En résumé : la bonne pratique 1. Toujours commencer les programmes en effaçant tous les objets de l espace de travail : rm(list=ls()) 2. Initialiser les objets à leurs tailles maximales 3. Utiliser des opérations vectorielles simples 4. Utiliser les fonctions.apply() si c est approprié 5. Faire les calculs une seule fois en dehors d une boucle plutôt qu à chaque itération 6. Avant d essayer de gagner en vitesse d exécution, penser à mesurer le temps d exécution 7. Penser à programmer en C pour gagner du temps 8. Ne pas oublier qu un code lisible, documenté et correct vaut mieux qu un programme faux et mal optimisé 6 A faire : parallélisation de la tâche Quand un ordinateur n est pas suffisamment rapide pour exécuter un programme, il est parfois possible de paralléliser le code, c est-à-dire de partager le travail demandé entre plusieurs ordinateurs voire entre plusieurs processeurs. Je ne m étendrai pas sur ce sujet car je n ai pu que tester la parallélisation entre les coeurs (cores) de mon ordinateur core2duo à l aide du package foeeach. C était un peu plus lent que le même programme exécuté sans parallélisation et cela s explique par l utilisation d un coeur par le système d exploitation et par R en même temps. N ayant pas à disposition un cluster d ordinateurs, je n ai pas pu vérifier l apport de ce type de parallélisation. Je conseille donc de lire le très bon article sur la parallélisation [4] dans lequel les auteurs ont comparé les différentes parallélisations et les différents packages de R permettant de paralléliser. 12

14 Références [1] Robin K. S. Hankin, Duncan Murdoch, and Andrew Clausen. Package gsl, [2] Owen Jones, Robert Maillardet, and Andrew Robinson. Introduction to Scientific Programming and Simulation Using R. Chapman & Hall/CRC, Mars [3] R Help Desk (Uwe Ligges and John Fox). How can i avoid this loop or make it faster? R News, 8/1, Mai [4] Markus Schmidberger, Martin Morgan, Dirk Eddelbuettel, Hao Yu, Luke Tierney, and Ulrich Mansmann. State of the art in parallel computing with r. Journal of Statistical Software, 31(1) :1 27, [5] W. Venables. Programmer s niche. R News, 1/1,