Tutoriel sur les boucles en R : usages et alternatives

Explication des boucles for

Cette structure, composée du rectangle d’« init » (initialisation), du losange de décision et du rectangle i1, s’exécute un nombre connu de fois.

En termes de logigramme, les rectangles signifient « exécuter une action sans prise de décision ». Les losanges sont des « symboles de décision » : ils traduisent des questions à deux issues logiques possibles, Vrai (T) ou Faux (F).

Note : pour simplifier, d’autres symboles possibles sont omis dans la figure.

Une ou plusieurs instructions d’initialisation sont suivies de l’évaluation d’une condition sur une variable qui parcourt une séquence. Dans la figure, le losange représente : « la valeur courante de la variable v appartient‑elle à la séquence seq ? ».

Autrement dit, vous testez si la valeur courante de v se situe dans un intervalle spécifié. Vous définissez généralement cet intervalle dans l’initialisation, par exemple 1:100, pour démarrer la boucle.

Si la condition n’est pas satisfaite (résultat False), la boucle ne s’exécute pas. C’est indiqué par la flèche sortante à droite de la structure for. Le programme passe alors à la première instruction après le bloc.

Si la condition est vérifiée, on exécute l’instruction (ou le bloc) i1. Ce bloc peut lui-même contenir une autre boucle : on parle alors de boucle imbriquée.

Une fois terminé, on réévalue la condition. Les lignes reliant i1 au sommet du schéma (après l’initialisation) l’indiquent. En R – comme en Python – on peut l’exprimer en anglais courant : notre variable appartient‑elle à une plage de valeurs ?

Note : dans d’autres langages, par exemple en C, la condition s’écrit plus explicitement avec des opérateurs logiques (supérieur, inférieur, égal, …).

Voici un exemple simple de boucle for :

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

Le bloc for est délimité par des accolades. Elles peuvent être placées juste après la condition ou à la ligne suivante, avec indentation. Rien n’est strictement obligatoire, mais les accolades améliorent la lisibilité et facilitent le repérage du bloc de boucle et d’éventuelles erreurs.

Note : le vecteur des carrés, usq, est initialisé. Ce n’est pas nécessaire en R « pur », mais dans la version markup, knitr ne compilerait pas car la référence au vecteur précède sa création. Pour en savoir plus sur knitr, consultez la page R Markdown.

Imbriquer des boucles for

Maintenant que vous savez qu’on peut imbriquer des boucles for, vous vous demandez sans doute pourquoi et quand le faire.

Supposons que vous souhaitiez manipuler un tableau bidimensionnel en fixant des valeurs pour ses éléments.

Vous pourriez écrire :

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

Astuce : pour plus d’informations sur matrix(), consultez la documentation R.

Vous avez deux boucles for imbriquées, donc deux paires d’accolades, chacune avec son bloc et son propre index : i parcourt les lignes et j les colonnes.

 

Qu’avez-vous produit ?

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Note : pour éviter d’inonder l’écran avec d’immenses tableaux, on ajoute une condition finale qui n’affiche que le bloc 10 x 10 si l’entier demandé est supérieur à 10. Sinon, un bloc n x n est affiché.

Le code complet ressemble à ceci :

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Boucles for : populaires, mais pas toujours idéales

La boucle for est de loin la plus utilisée, et sa construction implique un nombre d’itérations fixé et connu à l’avance, comme dans « générer les 200 premiers nombres premiers » ou « lister les 10 clients les plus importants ».

Mais si vous ne connaissez pas le nombre d’itérations, ou que des conditions imprévisibles peuvent survenir ?

Par exemple, vous pourriez vouloir compter les clients vivant dans une zone identifiée par un code postal, ou le nombre de clics sur une bannière au cours des deux derniers jours, ou d’autres événements non anticipés.

Dans ces cas, la boucle while et sa cousine repeat peuvent vous sauver…

Interrompre avec break

Quand l’interpréteur R rencontre break, il passe à l’instruction immédiatement après la boucle (s’il y en a une). Dans le cas de boucles imbriquées, break ne sort que de la boucle la plus interne.

Exemple :

Ce code définit une matrice m x n de zéros puis remplit ses cases via une double boucle for, mais seulement si les deux index diffèrent. L’objectif est de créer une matrice triangulaire inférieure : éléments sous la diagonale non nuls, le reste reste à zéro.

Quand les index sont égaux (condition sur j), un break interrompt la boucle interne et l’exécution reprend après celle-ci avec un print(). Puis on réévalue la condition de la boucle externe (i sur les lignes).

Si les index diffèrent, on assigne la valeur et on incrémente le compteur ctr. À la fin, on affiche ctr, le nombre d’assignations effectuées.

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)

Note : il est parfois prudent d’utiliser des accolades même lorsqu’elles ne sont pas strictement nécessaires, pour garantir que tout { ouvert est bien refermé par un }. Un déséquilibre signale une erreur potentielle.

Utiliser next dans une boucle

next interrompt l’itération en cours et passe à la suivante. En pratique, on saute directement à la réévaluation de la condition de boucle.

Dans d’autres langages, l’équivalent s’appelle « continue » : au moment où la condition est vérifiée, passez à l’itération suivante.

Exemple simple :

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

Ce code affiche tous les nombres impairs de 1:m (ici m=20). Les nombres dont le reste de la division par 2 est nul ne sont pas imprimés : le programme saute directement à l’évaluation de i in 1:m et ignore, ici, print(k).

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3

v3 = v1 + v2
v3

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C

Pourquoi la vectorisation est‑elle plus rapide ?

Pourquoi la vectorisation est‑elle plus rapide alors que le nombre d’opérations élémentaires semble identique ?

Sans entrer trop dans les détails : R est un langage interprété. L’interpréteur gère pour vous les détails de définition des variables. Il le fait commande par commande, même si vous répétez la même instruction.

Un compilateur, lui, résout ces définitions à la compilation et produit un code binaire compact et optimisé. Or, de nombreuses fonctions R sont écrites dans ces langages bas niveau, d’où une meilleure efficacité.

En pratique, le code bas niveau fait appel à du C/C++, encapsulé dans un « wrapper ».

Ensuite, dans les langages qui supportent la vectorisation (R, Matlab), toute instruction opérant sur un nombre agit en réalité sur un objet nativement défini comme un vecteur, même d’un seul élément. Les définitions sont donc résolues une fois pour l’ensemble du vecteur, au lieu d’être répétées élément par élément dans une boucle : c’est plus rapide.

Enfin, manipuler des vecteurs natifs permet d’utiliser des routines d’algèbre linéaire très efficaces (BLAS). En exécutant des instructions vectorisées, R s’appuie sur ces bibliothèques. Le message à retenir : traitez des structures complètes en un seul appel de fonction autant que possible.

Passons à un exemple général de vectorisation, avant d’examiner des fonctions R populaires pour remplacer les boucles.

Exemple de vectorisation en R

Revenons à la notion de « faire grossir les données », une manière peu efficace de « mettre à jour » un data frame.

On crée d’abord une matrice m x n avec replicate(m, rnorm(n)) où m=10 vecteurs colonne de n=10 éléments sont générés par rnorm(n).

Puis on la transforme en data frame (10 observations de 10 variables) et on applique une opération algébrique à chaque élément via une double boucle for : à chaque itération, on ajoute une composante sinusoïdale.

L’exemple est artificiel, mais il peut représenter l’ajout d’un signal à un bruit aléatoire :

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

Ici, la majeure partie du temps d’exécution est consacrée aux copies et à la gestion de la boucle.

Version vectorisée :

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

C’est plus simple : la dernière ligne remplace la double boucle. Note l’usage de set.seed() pour obtenir exactement le même résultat.

Mesurons maintenant les temps d’exécution.

Utilisez des commandes système R, comme system.time(), à laquelle vous passez un bloc de code :

Astuce : placez le code à évaluer entre les parenthèses de system.time().

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 

Dans le code ci-dessus, vous choisissez m et n, créez la matrice et le data frame une seule fois, puis vous comparez le bloc for à la version « une ligne » via deux appels séparés à system.time().

Même avec m=n=10, la version vectorisée est environ 7 fois plus rapide, bien que l’écart reste peu visible à ce niveau.

Les différences deviennent sensibles à m=n=100. À 1000, la boucle for semble suspendue plusieurs dizaines de secondes, tandis que la version vectorisée s’exécute instantanément.

Pour m=n=10000, la boucle for dépasse la minute quand la version vectorisée prend environ 2,54 s. Ces mesures varient selon votre configuration, mais elles illustrent l’écart.

À noter : augmenter m et n impacte aussi fortement la génération de la matrice (testez avec system.time() autour de replicate).

N’hésitez pas à jouer sur m et n et à tracer le temps d’exécution en fonction du produit m x n : c’est l’indicateur pertinent car il exprime la taille des matrices, donc le nombre d’itérations nécessaires dans la boucle imbriquée.

Ceci n’est qu’un exemple de vectorisation. Il en existe bien d’autres. Dans R News (p. 46), vous trouverez des fonctions très efficaces pour calculer des sommes et moyennes par dimension : rowSums(), colSums(), rowMeans(), colMeans().

La newsletter mentionne également que « …les fonctions de la famille ‘apply’, nommées [s,l,m,t]apply, permettent d’appliquer une autre fonction aux éléments/dimensions d’objets. Elles offrent une syntaxe compacte pour des tâches parfois complexes, plus lisible et plus rapide que des boucles mal écrites. »