Difference between revisions of "R/fr"

From CC Doc
Jump to: navigation, search
(Updating to match new version of source page)
 
(103 intermediate revisions by 4 users not shown)
Line 4: Line 4:
 
R est un outil de calcul statistique et de graphiques. Il s'agit d'un langage de programmation additionné d'un environnement graphique, d'un débogueur, de l'accès à certaines fonctions de système et de la possibilité d'exécuter des scripts.
 
R est un outil de calcul statistique et de graphiques. Il s'agit d'un langage de programmation additionné d'un environnement graphique, d'un débogueur, de l'accès à certaines fonctions de système et de la possibilité d'exécuter des scripts.
  
Même si R n'a pas été développé pour le calcul de haute performance, sa popularité au sein de plusieurs disciplines scientifiques incluant l'ingénierie, les mathématiques, la statistique et la bioinformatique, en fait un outil essentiel sur les supercalculateurs dédiés à la recherche académique. Certaines fonctionnalités étant écrites en C, compilées et parallélisées par fils d'exécution, permettent d'atteindre des performances raisonnables sur un seul nœud de calcul. Grâce à la nature modulaire de R, les utilisateurs peuvent personnaliser leur configuration en installant des paquets dans leur répertoire personnel à partir du ''Comprehensive R Archive Network'' ([https://cran.r-project.org/ CRAN]).
+
Même si R n'a pas été développé pour le calcul de haute performance, sa popularité au sein de plusieurs disciplines scientifiques incluant le génie, les mathématiques, la statistique et la bio-informatique, en fait un outil essentiel sur les supercalculateurs dédiés à la recherche académique. Certaines fonctionnalités étant écrites en C, compilées et parallélisées par fils d'exécution, permettent d'atteindre des performances raisonnables sur un seul nœud de calcul. Grâce à la nature modulaire de R, les utilisateurs peuvent personnaliser leur configuration en installant des paquets dans leur répertoire personnel à partir du ''Comprehensive R Archive Network'' ([https://cran.r-project.org/ CRAN]).
  
== L'interpréteur R ==
+
== Interpréteur ==
Chargez d'abord un module R. Comme plusieurs versions seront probablement disponibles, consultez la liste en lançant la commande   
+
Chargez d'abord un module R. Comme plusieurs versions sont disponibles, consultez la liste en lançant la commande   
 
{{Commande
 
{{Commande
 
|module spider r
 
|module spider r
 
}}
 
}}
Pour charger un module R particulier, lancez la commande   
+
Pour charger un module R particulier, utilisez une variante de la commande   
 
{{Commande
 
{{Commande
 
|module load r/3.3.3
 
|module load r/3.3.3
 
}}  
 
}}  
Lorsque R est chargé dans votre environnement, vous pouvez démarrer l'interpréteur R et exécuter du code R dans cet environnement :
+
 
 +
Vous devrez probablement charger aussi gcc avec
 +
{{Command
 +
|module load gcc/5.4.0
 +
}}
 +
 
 +
Dépendant des paquets dont vous avez besoin, vous pourriez devoir installer d'autres modules. Par exemple, ''rgdal'' exige que le module ''gdal'' soit chargé et ''gdal'' exige à son tour ''nixpkgs'' et ''gcc''. Par défaut, ''nixpfks'' devrait être chargé, mais vérifiez qu'il l'est avec
 +
 
 +
{{Command
 +
|module list
 +
}}
 +
 
 +
Si nixpkgs n'est pas listé, chargez-le avec
 +
 
 +
{{Command
 +
|module load nixpkgs/16.09
 +
}}
 +
 
 +
Si l'installation d'un paquet échoue, portez attention au message d'erreur qui pourrait indiquer d'autres modules qui seraient nécessaires. Pour savoir s'il y a une dépendance avec un autre module, lancez
 +
{{Command
 +
|module spider gdal/2.2.1
 +
}}
 +
 
 +
Une fois tous les modules chargés dans votre environnement, démarrez l'interpréteur et entrez le code R dans cet environnement.
 
{{Command
 
{{Command
 
|lang="R"
 
|lang="R"
Line 43: Line 66:
 
> q()
 
> q()
 
}}
 
}}
 
 
Pour exécuter des scripts R, utilisez la commande <tt>Rscript</tt> suivie du fichier contenant les commandes R :
 
Pour exécuter des scripts R, utilisez la commande <tt>Rscript</tt> suivie du fichier contenant les commandes R :
  
{{Commande|Rscript computation.R}}
+
{{Command|Rscript computation.R}}
  
Cette commande passera automatiquement les options appropriées pour un traitement en lot, soit <tt>&#8209;&#8209;slave</tt> et <tt>&#8209;&#8209;no&#8209;restore</tt> à l'interpréteur R. Ces options empêcheront la création de fichiers d'espace de travail inutiles avec <tt>&#8209;&#8209;no&#8209;save</tt> lors d'un traitement en lot.
+
Cette commande passera automatiquement les options appropriées pour un traitement en lot, soit <tt>--slave</tt> et <tt>--no-restore</tt> à l'interpréteur R. Ces options empêcheront la création de fichiers d'espace de travail inutiles avec <tt>--no-save</tt> lors d'un traitement en lot.
  
 
== Installer des paquets R ==
 
== Installer des paquets R ==
Pour installer des paquets du répertoire [https://cran.r-project.org/ CRAN], vous pouvez utiliser la commande <tt>install.packages</tt> à l'intérieur de R. Par exemple, pour installer le paquet <tt>sp</tt> pour des données spatiales, exécutez sur le nœud frontal (''login node'') la commande
+
Pour installer des paquets du répertoire [https://cran.r-project.org/ CRAN], vous pouvez utiliser la commande <tt>install.packages</tt> à l'intérieur de R. Comme plusieurs paquets R sont développés avec la famille de compilateurs [[GNU Parallel/fr|GNU]] nous recommandons de charger un module <tt>gcc</tt> avant d'installer un paquet R et d'utiliser la même version de <tt>gcc</tt> pour tous les paquets.
  
{{Commande
+
{{Command
 +
|module load gcc/5.4.0
 +
}}
 +
Par exemple, pour installer le paquet <tt>sp</tt> qui offre des classes et des méthodes pour les données spatiales, utilisez cette commande sur un nœud de connexion.
 +
 
 +
{{Command
 
|R
 
|R
 
|result=
 
|result=
[...]
+
[...]
 
> install.packages("sp")
 
> install.packages("sp")
 
}}
 
}}
  
Lorsque R vous le demandera, sélectionnez un miroir pour le téléchargement. Idéalement, ce miroir sera géographiquement proche de la grappe que vous utilisez.
+
Lorsque R vous le demande, sélectionnez un miroir pour le téléchargement. Idéalement, ce miroir sera géographiquement proche de la grappe que vous utilisez.
 +
 
 +
Avant l'installation, certains paquets requièrent la définition de la variable d'environnement <tt>TMPDIR</tt>. D'autres paquets fonctionnent avec un compilateur GNU C et/ou C++ plutôt qu'avec un compilateur de type Intel. Il est donc préférable de charger d'abord un des modules <tt>gcc</tt> avant de lancer R.
  
Avant l'installation, certains paquets requièrent la définition de la variable d'environnement <tt>TMPDIR</tt>. D'autres paquets fonctionneront avec un compilateur Gnu C et/ou C++ plutôt qu'avec un compilateur de type Intel. Il est donc préférable de charger d'abord un des modules <tt>gcc</tt> avant de lancer R.
+
Si vous cherchez à installer un paquet que vous avez téléchargé, supposons que l'archive se nomme tt>archive_package.tgz</tt> (utile pour un paquet qui n'appartient pas au domaine CRAN), entrez la commande suivante dans votre interpréteur de commandes :
  
Si vous cherchez à installer un paquet que vous avez téléchargé, supposons que l'archive se nomme <tt>paquet_archive.tgz</tt> (utile pour un paquet qui n'appartient pas au domaine CRAN), entrez la commande suivante dans votre interpréteur de commandes&nbsp;:
+
{{Command
{{Commande
+
|R CMD INSTALL -l 'path for your local (home) R library' archive_package.tgz
|R CMD INSTALL -l 'chemin pour votre bibliothèque locale (personnelle) R' paquet_archive.tgz
 
 
}}
 
}}
 +
 +
==Parallélisation==
 +
De par leur nature, les grappes de Calcul Canada sont un environnement idéal pour exécuter du code R parallèle. Nous présentons ici deux méthodes de parallélisation que nous vous encourageons à considérer. Si les processeurs sur les grappes de Calcul Canada sont des processeurs on ne peut plus ordinaires, ce qui rend ces ''super''calculateurs intéressants, c'est qu'ils offrent des milliers de CPU sur un réseau très performant. La parallélisation fait bon usage de ce type de matériel.
  
 
=== Rmpi ===
 
=== Rmpi ===
Line 76: Line 107:
 
1. Voyez les modules R disponibles avec la commande
 
1. Voyez les modules R disponibles avec la commande
 
  <source lang="bash">
 
  <source lang="bash">
module spider r
+
module spider r
 
</source>
 
</source>
  
2. Sélectionnez la dernière version (novembre 2017) et chargez le module OpenMPI approprié.
+
2. Sélectionnez une version (par exemple, 3.4.0) et chargez le module OpenMPI approprié.
 
  <source lang="bash">
 
  <source lang="bash">
module load r/3.4.0
+
module load r/3.4.0
module load openmpi/1.10.7
+
module load openmpi/1.10.7
</sourc
+
</source>
  
<div class="mw-translate-fuzzy">
+
3. Téléchargez [https://cran.r-project.org/web/packages/Rmpi/index.html la dernière version de R] en remplaçant le numéro de la version selon le cas.
3. Téléchargez [https://cran.r-project.org/web/packages/Rmpi/index.html la dernière version de R] en remplaçant le numéro de la version selon le cas.
+
<source lang="bash">
</div>
+
wget https://cran.r-project.org/src/contrib/Rmpi_0.6-6.tar.gz
 +
</source>
  
<div class="mw-translate-fuzzy">
 
 
4. Indiquez le répertoire dans lequel vous voulez copier les fichiers; vous devez avoir une permission d'écriture pour ce répertoire. Le nom du répertoire peut être modifié.
 
4. Indiquez le répertoire dans lequel vous voulez copier les fichiers; vous devez avoir une permission d'écriture pour ce répertoire. Le nom du répertoire peut être modifié.
</div>
+
<source lang="bash">
 +
mkdir -p ~/local/R_libs/
 +
export R_LIBS=~/local/R_libs/
 +
</source>
  
<div class="mw-translate-fuzzy">
 
 
5. Lancez la commande d'installation.
 
5. Lancez la commande d'installation.
</div>
+
<source lang="bash">
 +
R CMD INSTALL --configure-args="--with-Rmpi-include=$EBROOTOPENMPI/include  --with-Rmpi-libpath=$EBROOTOPENMPI/lib --with-Rmpi-type='OPENMPI' " Rmpi_0.6-6.tar.gz
 +
</source>
  
Cette procédure utilise la version 1.10.7 qui est nécessaire pour bien démarrer les processus. Notez que le module par défaut (2.1.1) ne fonctionne pas bien présentement.
+
Cette procédure utilise la version 1.10.7 qui est nécessaire pour bien démarrer les processus. Notez que le module par défaut (2.1.1) ne fonctionne pas bien présentement. Portez attention au message d'erreur qui s'affiche quand l'installation d'un paquet échoue; il pourrait indiquer d'autres modules qui seraient nécessaires.
  
 
====Exécution====
 
====Exécution====
  
<div class="mw-translate-fuzzy">
 
 
1. Placez le code R dans un fichier script, ici le fichier ''test.R''.
 
1. Placez le code R dans un fichier script, ici le fichier ''test.R''.
</div>
 
  
  <source lang="r">
+
  {{File
#Tell all slaves to return a message identifying themselves.
+
  |name=test.R
  library("Rmpi")
+
  |lang="r"
  sprintf("TEST mpi.universe.size() =  %i", mpi.universe.size())
+
  |contents=
  ns <- mpi.universe.size() - 1
+
#Tell all slaves to return a message identifying themselves.
  sprintf("TEST attempt to spawn %i slaves", ns)
+
library("Rmpi")
  mpi.spawn.Rslaves(nslaves=ns)
+
sprintf("TEST mpi.universe.size() =  %i", mpi.universe.size())
  mpi.remote.exec(paste("I am",mpi.comm.rank(),"of",mpi.comm.size()))
+
ns <- mpi.universe.size() - 1
  mpi.remote.exec(paste(mpi.comm.get.parent()))
+
sprintf("TEST attempt to spawn %i slaves", ns)
  #Send execution commands to the slaves
+
mpi.spawn.Rslaves(nslaves=ns)
  x<-5
+
mpi.remote.exec(paste("I am",mpi.comm.rank(),"of",mpi.comm.size()))
  #These would all be pretty correlated one would think
+
mpi.remote.exec(paste(mpi.comm.get.parent()))
  x<-mpi.remote.exec(rnorm,x)
+
#Send execution commands to the slaves
  length(x)
+
x<-5
   x
+
#These would all be pretty correlated one would think
</source>
+
x<-mpi.remote.exec(rnorm,x)
 +
length(x)
 +
x
 +
mpi.close.Rslaves()
 +
mpi.quit()
 +
}}
 +
 
 +
2. Copiez ce qui suit dans le script ''job.sh''.
 +
 
 +
{{File
 +
  |name=job.sh
 +
  |lang="bash"
 +
  |contents=
 +
#!/bin/bash
 +
#SBATCH --account=def-someacct   # replace this with your own account
 +
#SBATCH --ntasks=5              # number of MPI processes
 +
#SBATCH --mem-per-cpu=2048M      # memory; default unit is megabytes
 +
#SBATCH --time=0-00:15          # time (DD-HH:MM)
 +
module load r/3.4.0
 +
module load openmpi/1.10.7
 +
export R_LIBS=~/local/R_libs/
 +
mpirun -np 1 R CMD BATCH test.R test.txt
 +
}}
  
<div class="mw-translate-fuzzy">
+
3. Soumettez la tâche.
2. Copiez ce qui suit dans le script job.sh.
 
</div>
 
  
 
  <source lang="bash">
 
  <source lang="bash">
#!/bin/bash
+
sbatch job.sh
#SBATCH --account=def-ppomorsk # replace this with your own account
 
#SBATCH --ntasks=5              # number of MPI processes
 
#SBATCH --mem-per-cpu=2048M      # memory; default unit is megabytes
 
#SBATCH --time=0-00:15          # time (DD-HH:MM)
 
module load r/3.4.0
 
module load openmpi/1.10.7
 
export R_LIBS=~/local/R_libs/
 
mpirun -np 1 R CMD BATCH test.R test.txt
 
 
</source>
 
</source>
  
<div class="mw-translate-fuzzy">
+
Pour plus d'information sur comment soumettre des tâches, consultez [[Running jobs/fr|Exécuter des tâches]].
 +
 
 +
=== doParallel et foreach ===
 +
====Utilisation====
 +
Foreach peut être vu comme une interface unifiée pour tous les systèmes dorsaux (''backends'') comme doMC, doMPI, doParallel, doRedis, etc. et fonctionne sur toutes les plateformes en autant que le système dorsal est fonctionnel. doParallel agit comme interface entre foreach et le paquet parallèle et peut être chargé seul. Certains problèmes surviennent avec foreach lors de l'exécution d'un très grand nombre de très petites tâches. Notez que l'exemple simple qui suit n'utilise pas l'appel foreach() de façon optimale.
 +
 
 +
Enregistrez le système dorsal en lui indiquant le nombre de cœurs disponibles. Si le système dorsal n'est pas enregistré, foreach assume que le nombre de cœurs est 1 et exécute les itérations de façon séquentielles.
 +
 
 +
De façon générale, la procédure est de :
 +
# charger foreach et le paquet du système dorsal;
 +
# enregistrer le système dorsal;
 +
# appeler foreach() sur la même ligne que %do% (série) ou de l'opérateur %dopar%.
 +
====Exécution====
 +
 
 +
1. Placez le code R dans un fichier script, ici le fichier ''test_foreach.R''.
 +
 
 +
{{File
 +
  |name=test_foreach.R
 +
  |lang="r"
 +
  |contents=
 +
# library(foreach) # optional if using doParallel
 +
library(doParallel) #
 +
 
 +
# a very simple function
 +
test_func <- function(var1, var2) {
 +
    return(var1*var2)
 +
}
 +
 
 +
# we will iterate over two sets of values, you can modify this to explore the mechanism of foreach
 +
var1.v = c(1:8)
 +
var2.v = seq(0.1, 1, length.out = 8)
 +
 
 +
# Use the environment variable SLURM_NTASKS to set the number of cores.
 +
# This is for SLURM. Replace SLURM_NTASKS by the proper variable for your system.
 +
# Avoid manually setting a number of cores.
 +
ncores = Sys.getenv("SLURM_NTASKS")
 +
 
 +
registerDoParallel(cores=ncores)# Shows the number of Parallel Workers to be used
 +
print(ncores) # this how many cores are available, and how many you have requested.
 +
getDoParWorkers()# you can compare with the number of actual workers
 +
 
 +
# be careful! foreach() and %dopar% must be on the same line!
 +
foreach(var1=var1.v, .combine=rbind) %:% foreach(var2=var2.v, .combine=rbind) %dopar% {test_func(var1=var1, var2=var2)}
 +
}}
 +
 
 +
 
 +
Copiez ce qui suit dans le script ''job_foreach.sh''.
 +
 
 +
{{File
 +
  |name=job_foreach.sh
 +
  |lang="bash"
 +
  |contents=
 +
#!/bin/bash
 +
#SBATCH --account=def-someacct  # replace this with your own account
 +
#SBATCH --ntasks=4              # number of processes
 +
#SBATCH --mem-per-cpu=2048M      # memory; default unit is megabytes
 +
#SBATCH --time=0-00:15          # time (DD-HH:MM)
 +
#SBATCH --mail-user=yourname@someplace.com # Send email updates to you or someone else
 +
#SBATCH --mail-type=ALL          # send an email in all cases (job started, job ended, job aborted)
 +
 
 +
module load r/3.4.3
 +
export R_LIBS=~/local/R_libs/
 +
R CMD BATCH --no-save --no-restore test_foreach.R
 +
}}
 +
 
 
3. Soumettez la tâche.
 
3. Soumettez la tâche.
</div>
 
  
<source lang="bash">
+
<div class="mw-translate-fuzzy">
sbatch job.sh
+
<source lang="bash">
 +
sbatch job_foreach.sh
 
</source>
 
</source>
 +
</div>
  
 
Pour plus d'information sur comment soumettre des tâches, consultez [[Running jobs/fr|Exécuter des tâches]].
 
Pour plus d'information sur comment soumettre des tâches, consultez [[Running jobs/fr|Exécuter des tâches]].
 +
 +
=== doParallel and makeCluster ===
 +
====Usage====
 +
You must register the backend by feeding it the nodes name multiplied by the desired number of processes. For instance, with two nodes (node1 and node2) and two processes, we would create a cluster composed of : <tt>node1 node1 node2 node2</tt> hosts. The ''PSOCK'' cluster type will run commands through SSH connections into the nodes.
 +
 +
====Running====
 +
1. Place your R code in a script file, in this case the file is called <tt>test_makecluster.R</tt>.
 +
{{File
 +
  |name=test_makecluster.R
 +
  |lang="r"
 +
  |contents=
 +
library(doParallel)
 +
 +
# Create an array from the NODESLIST environnement variable
 +
nodeslist = unlist(strsplit(Sys.getenv("NODESLIST"), split=" "))
 +
 +
# Create the cluster with the nodes name. One process per count of node name.
 +
# nodeslist = node1 node1 node2 node2, means we are starting 2 processes on node1, likewise on node2.
 +
cl = makeCluster(nodeslist, type = "PSOCK")
 +
registerDoParallel(cl)
 +
 +
# Compute (Source : https://cran.r-project.org/web/packages/doParallel/vignettes/gettingstartedParallel.pdf)
 +
x <- iris[which(iris[,5] != "setosa"), c(1,5)]
 +
trials <- 10000
 +
ptime <- system.time({
 +
    foreach(icount(trials), .combine=cbind) %dopar%
 +
    {
 +
        ind <- sample(100, 100, replace=TRUE)
 +
        result1 <- glm(x[ind,2]~x[ind,1], family=binomial(logit))
 +
        coefficients(result1)
 +
    }
 +
})
 +
ptime[3]
 +
 +
# Don't forget to release resources
 +
stopCluster(cl)
 +
}}
 +
 +
2. Copy the following content in a job submission script called <tt>job_makecluster.sh</tt>:
 +
{{File
 +
  |name=job_makecluster.sh
 +
  |lang="bash"
 +
  |contents=
 +
#!/bin/bash
 +
#SBATCH --account=def-someacct  # replace this with your own account
 +
#SBATCH --ntasks=4              # number of processes
 +
#SBATCH --mem-per-cpu=512M      # memory; default unit is megabytes
 +
#SBATCH --time=00:05:00        # time (HH:MM:SS)
 +
 +
module load r/3.5.0
 +
 +
# Export the nodes names.
 +
# If all processes are allocated on the same node, NODESLIST contains : node1 node1 node1 node1
 +
export NODESLIST=$(echo $(srun hostname))
 +
R -f test_makecluster.R
 +
}}
 +
 +
3. Submit the job with:
 +
{{Command|sbatch job_makecluster.sh}}
 +
For more information on submitting jobs, see the [[Running jobs]] page.

Latest revision as of 00:55, 7 August 2018

Other languages:
English • ‎français

R est un outil de calcul statistique et de graphiques. Il s'agit d'un langage de programmation additionné d'un environnement graphique, d'un débogueur, de l'accès à certaines fonctions de système et de la possibilité d'exécuter des scripts.

Même si R n'a pas été développé pour le calcul de haute performance, sa popularité au sein de plusieurs disciplines scientifiques incluant le génie, les mathématiques, la statistique et la bio-informatique, en fait un outil essentiel sur les supercalculateurs dédiés à la recherche académique. Certaines fonctionnalités étant écrites en C, compilées et parallélisées par fils d'exécution, permettent d'atteindre des performances raisonnables sur un seul nœud de calcul. Grâce à la nature modulaire de R, les utilisateurs peuvent personnaliser leur configuration en installant des paquets dans leur répertoire personnel à partir du Comprehensive R Archive Network (CRAN).

Interpréteur

Chargez d'abord un module R. Comme plusieurs versions sont disponibles, consultez la liste en lançant la commande

[nom@serveur ~]$ module spider r

Pour charger un module R particulier, utilisez une variante de la commande

[nom@serveur ~]$ module load r/3.3.3

Vous devrez probablement charger aussi gcc avec

[name@server ~]$ module load gcc/5.4.0

Dépendant des paquets dont vous avez besoin, vous pourriez devoir installer d'autres modules. Par exemple, rgdal exige que le module gdal soit chargé et gdal exige à son tour nixpkgs et gcc. Par défaut, nixpfks devrait être chargé, mais vérifiez qu'il l'est avec

[name@server ~]$ module list

Si nixpkgs n'est pas listé, chargez-le avec

[name@server ~]$ module load nixpkgs/16.09

Si l'installation d'un paquet échoue, portez attention au message d'erreur qui pourrait indiquer d'autres modules qui seraient nécessaires. Pour savoir s'il y a une dépendance avec un autre module, lancez

[name@server ~]$ module spider gdal/2.2.1

Une fois tous les modules chargés dans votre environnement, démarrez l'interpréteur et entrez le code R dans cet environnement.

[name@server ~]$ R
R version 3.3.3 (2017-03-06) -- "Another Canoe"
Copyright (C) 2017 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

  Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> values <- c(3,5,7,9)
> values[0]
[1] 3
> q()

Pour exécuter des scripts R, utilisez la commande Rscript suivie du fichier contenant les commandes R :

[name@server ~]$ Rscript computation.R

Cette commande passera automatiquement les options appropriées pour un traitement en lot, soit --slave et --no-restore à l'interpréteur R. Ces options empêcheront la création de fichiers d'espace de travail inutiles avec --no-save lors d'un traitement en lot.

Installer des paquets R

Pour installer des paquets du répertoire CRAN, vous pouvez utiliser la commande install.packages à l'intérieur de R. Comme plusieurs paquets R sont développés avec la famille de compilateurs GNU nous recommandons de charger un module gcc avant d'installer un paquet R et d'utiliser la même version de gcc pour tous les paquets.

[name@server ~]$ module load gcc/5.4.0

Par exemple, pour installer le paquet sp qui offre des classes et des méthodes pour les données spatiales, utilisez cette commande sur un nœud de connexion.

[name@server ~]$ R
[...]
> install.packages("sp")

Lorsque R vous le demande, sélectionnez un miroir pour le téléchargement. Idéalement, ce miroir sera géographiquement proche de la grappe que vous utilisez.

Avant l'installation, certains paquets requièrent la définition de la variable d'environnement TMPDIR. D'autres paquets fonctionnent avec un compilateur GNU C et/ou C++ plutôt qu'avec un compilateur de type Intel. Il est donc préférable de charger d'abord un des modules gcc avant de lancer R.

Si vous cherchez à installer un paquet que vous avez téléchargé, supposons que l'archive se nomme tt>archive_package.tgz</tt> (utile pour un paquet qui n'appartient pas au domaine CRAN), entrez la commande suivante dans votre interpréteur de commandes :

[name@server ~]$ R CMD INSTALL -l 'path for your local (home) R library' archive_package.tgz

Parallélisation

De par leur nature, les grappes de Calcul Canada sont un environnement idéal pour exécuter du code R parallèle. Nous présentons ici deux méthodes de parallélisation que nous vous encourageons à considérer. Si les processeurs sur les grappes de Calcul Canada sont des processeurs on ne peut plus ordinaires, ce qui rend ces supercalculateurs intéressants, c'est qu'ils offrent des milliers de CPU sur un réseau très performant. La parallélisation fait bon usage de ce type de matériel.

Rmpi

Installation

La procédure suivante installe Rmpi, une interface (wrapper) pour les routines MPIMessage Passing Interface qui permet d'exécuter R en parallèle.

1. Voyez les modules R disponibles avec la commande

module spider r

2. Sélectionnez une version (par exemple, 3.4.0) et chargez le module OpenMPI approprié.

module load r/3.4.0
module load openmpi/1.10.7

3. Téléchargez la dernière version de R en remplaçant le numéro de la version selon le cas.

wget https://cran.r-project.org/src/contrib/Rmpi_0.6-6.tar.gz

4. Indiquez le répertoire dans lequel vous voulez copier les fichiers; vous devez avoir une permission d'écriture pour ce répertoire. Le nom du répertoire peut être modifié.

mkdir -p ~/local/R_libs/
export R_LIBS=~/local/R_libs/

5. Lancez la commande d'installation.

R CMD INSTALL --configure-args="--with-Rmpi-include=$EBROOTOPENMPI/include   --with-Rmpi-libpath=$EBROOTOPENMPI/lib --with-Rmpi-type='OPENMPI' " Rmpi_0.6-6.tar.gz

Cette procédure utilise la version 1.10.7 qui est nécessaire pour bien démarrer les processus. Notez que le module par défaut (2.1.1) ne fonctionne pas bien présentement. Portez attention au message d'erreur qui s'affiche quand l'installation d'un paquet échoue; il pourrait indiquer d'autres modules qui seraient nécessaires.

Exécution

1. Placez le code R dans un fichier script, ici le fichier test.R.


File : test.R

#Tell all slaves to return a message identifying themselves.
library("Rmpi")
sprintf("TEST mpi.universe.size() =  %i", mpi.universe.size())
ns <- mpi.universe.size() - 1
sprintf("TEST attempt to spawn %i slaves", ns)
mpi.spawn.Rslaves(nslaves=ns)
mpi.remote.exec(paste("I am",mpi.comm.rank(),"of",mpi.comm.size()))
mpi.remote.exec(paste(mpi.comm.get.parent()))
#Send execution commands to the slaves
x<-5
#These would all be pretty correlated one would think
x<-mpi.remote.exec(rnorm,x)
length(x)
x
mpi.close.Rslaves()
mpi.quit()


2. Copiez ce qui suit dans le script job.sh.


File : job.sh

#!/bin/bash
#SBATCH --account=def-someacct   # replace this with your own account
#SBATCH --ntasks=5               # number of MPI processes
#SBATCH --mem-per-cpu=2048M      # memory; default unit is megabytes
#SBATCH --time=0-00:15           # time (DD-HH:MM)
module load r/3.4.0
module load openmpi/1.10.7
export R_LIBS=~/local/R_libs/
mpirun -np 1 R CMD BATCH test.R test.txt


3. Soumettez la tâche.

sbatch job.sh

Pour plus d'information sur comment soumettre des tâches, consultez Exécuter des tâches.

doParallel et foreach

Utilisation

Foreach peut être vu comme une interface unifiée pour tous les systèmes dorsaux (backends) comme doMC, doMPI, doParallel, doRedis, etc. et fonctionne sur toutes les plateformes en autant que le système dorsal est fonctionnel. doParallel agit comme interface entre foreach et le paquet parallèle et peut être chargé seul. Certains problèmes surviennent avec foreach lors de l'exécution d'un très grand nombre de très petites tâches. Notez que l'exemple simple qui suit n'utilise pas l'appel foreach() de façon optimale.

Enregistrez le système dorsal en lui indiquant le nombre de cœurs disponibles. Si le système dorsal n'est pas enregistré, foreach assume que le nombre de cœurs est 1 et exécute les itérations de façon séquentielles.

De façon générale, la procédure est de :

  1. charger foreach et le paquet du système dorsal;
  2. enregistrer le système dorsal;
  3. appeler foreach() sur la même ligne que %do% (série) ou de l'opérateur %dopar%.

Exécution

1. Placez le code R dans un fichier script, ici le fichier test_foreach.R.


File : test_foreach.R

# library(foreach) # optional if using doParallel
library(doParallel) #

# a very simple function
test_func <- function(var1, var2) {
    return(var1*var2)
}

# we will iterate over two sets of values, you can modify this to explore the mechanism of foreach
var1.v = c(1:8)
var2.v = seq(0.1, 1, length.out = 8)

# Use the environment variable SLURM_NTASKS to set the number of cores.
# This is for SLURM. Replace SLURM_NTASKS by the proper variable for your system.
# Avoid manually setting a number of cores.
ncores = Sys.getenv("SLURM_NTASKS") 

registerDoParallel(cores=ncores)# Shows the number of Parallel Workers to be used
print(ncores) # this how many cores are available, and how many you have requested.
getDoParWorkers()# you can compare with the number of actual workers

# be careful! foreach() and %dopar% must be on the same line!
foreach(var1=var1.v, .combine=rbind) %:% foreach(var2=var2.v, .combine=rbind) %dopar% {test_func(var1=var1, var2=var2)}



Copiez ce qui suit dans le script job_foreach.sh.


File : job_foreach.sh

#!/bin/bash
#SBATCH --account=def-someacct   # replace this with your own account
#SBATCH --ntasks=4               # number of processes
#SBATCH --mem-per-cpu=2048M      # memory; default unit is megabytes
#SBATCH --time=0-00:15           # time (DD-HH:MM)
#SBATCH --mail-user=yourname@someplace.com # Send email updates to you or someone else
#SBATCH --mail-type=ALL          # send an email in all cases (job started, job ended, job aborted)

module load r/3.4.3
export R_LIBS=~/local/R_libs/
R CMD BATCH --no-save --no-restore test_foreach.R


3. Soumettez la tâche.

sbatch job_foreach.sh

Pour plus d'information sur comment soumettre des tâches, consultez Exécuter des tâches.

doParallel and makeCluster

Usage

You must register the backend by feeding it the nodes name multiplied by the desired number of processes. For instance, with two nodes (node1 and node2) and two processes, we would create a cluster composed of : node1 node1 node2 node2 hosts. The PSOCK cluster type will run commands through SSH connections into the nodes.

Running

1. Place your R code in a script file, in this case the file is called test_makecluster.R.

File : test_makecluster.R

library(doParallel)

# Create an array from the NODESLIST environnement variable
nodeslist = unlist(strsplit(Sys.getenv("NODESLIST"), split=" "))

# Create the cluster with the nodes name. One process per count of node name.
# nodeslist = node1 node1 node2 node2, means we are starting 2 processes on node1, likewise on node2.
cl = makeCluster(nodeslist, type = "PSOCK") 
registerDoParallel(cl)

# Compute (Source : https://cran.r-project.org/web/packages/doParallel/vignettes/gettingstartedParallel.pdf)
x <- iris[which(iris[,5] != "setosa"), c(1,5)]
trials <- 10000
ptime <- system.time({
    foreach(icount(trials), .combine=cbind) %dopar%
    {
        ind <- sample(100, 100, replace=TRUE)
        result1 <- glm(x[ind,2]~x[ind,1], family=binomial(logit))
        coefficients(result1)
    }
})
ptime[3]

# Don't forget to release resources
stopCluster(cl)


2. Copy the following content in a job submission script called job_makecluster.sh:

File : job_makecluster.sh

#!/bin/bash
#SBATCH --account=def-someacct  # replace this with your own account
#SBATCH --ntasks=4              # number of processes
#SBATCH --mem-per-cpu=512M      # memory; default unit is megabytes
#SBATCH --time=00:05:00         # time (HH:MM:SS)

module load r/3.5.0

# Export the nodes names. 
# If all processes are allocated on the same node, NODESLIST contains : node1 node1 node1 node1
export NODESLIST=$(echo $(srun hostname))
R -f test_makecluster.R


3. Submit the job with:

[name@server ~]$ sbatch job_makecluster.sh

For more information on submitting jobs, see the Running jobs page.