TensorFlow/fr

TensorFlow est une bibliothèque logicielle open source d'apprentissage machine.

Installation

Les directives suivantes servent à installer TensorFlow dans votre répertoire personnel (home) à l'aide des (wheels Python ) préparés par Calcul Canada; ils se trouvent dans /cvmfs/soft.computecanada.ca/custom/python/wheelhouse/.
Le wheel TensorFlow sera installé dans un environnement virtuel Python avec la commande pip.
Ces directives sont valides pour Python 3.6; d'autres versions peuvent être installées en utilisant le module approprié.

Chargez les modules requis par TensorFlow.

[name@server ~]$ module load python/3.6

Créez un nouvel environnement Python.

[name@server ~]$ virtualenv --no-download tensorflow

Activez le nouvel environnement.

[name@server ~]$ source tensorflow/bin/activate

Pour installer TensorFlow dans votre nouvel environnement virtuel, voyez les sections ci-dessous.

N'installez pas le paquet tensorflow sans le suffixe _cpu ou _gpu car il existe des problèmes de compatibilité avec d'autres bibliothèques.

CPU seulement

(tensorflow)_[name@server ~]$ pip install --no-index tensorflow_cpu

GPU

(tensorflow)_[name@server ~]$ pip install --no-index tensorflow_gpu

Le paquet R

Pour utiliser TensorFlow en R, suivez les directives données ci-dessus pour créer un environnement virtuel et y installer TensorFlow. Suivez ensuite cette procédure ː

Chargez les modules requis.

[name@server ~]$ module load gcc r

Activez votre environnement virtuel Python.

[name@server ~]$ source tensorflow/bin/activate

Lancez R.

(tensorflow)_[name@server ~]$ R

En R, installez le paquet devtools, puis TensorFlow :

install.packages('devtools', repos='https://cloud.r-project.org')
devtools::install_github('rstudio/tensorflow')

Vous pouvez maintenant procéder. N'appelez pas install_tensorflow() en R puisque TensorFlow est déjà installé dans votre environnement virtuel avec pip. Pour utiliser TensorFlow tel qu'installé dans votre environnement virtuel, entrez les commandes suivantes en R, après que l'environnement est activé.

library(tensorflow)
use_virtualenv(Sys.getenv('VIRTUAL_ENV'))

Soumettre une tâche TensorFlow avec un GPU

Soumettez une tâche TensorFlow ainsi

[name@server ~]$ sbatch tensorflow-test.sh

Le script contient

File : tensorflow-test.sh

#!/bin/bash
#SBATCH --gres=gpu:1        # request GPU "generic resource"
#SBATCH --cpus-per-task=6   # maximum CPU cores per GPU request: 6 on Cedar, 16 on Graham.
#SBATCH --mem=32000M        # memory per node
#SBATCH --time=0-03:00      # time (DD-HH:MM)
#SBATCH --output=%N-%j.out  # %N for node name, %j for jobID

module load cuda cudnn 
source tensorflow/bin/activate
python ./tensorflow-test.py

Le script Python se lit

File : tensorflow-test.py

import tensorflow as tf
node1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)
sess = tf.Session()
print(sess.run([node1, node2]))

Une fois la tâche complétée, ce qui devrait nécessiter moins d'une minute, un fichier de sortie avec un nom semblable à cdr116-122907.out devrait être généré. Le contenu de ce fichier serait similaire à ce qui suit :

File : cdr116-122907.out

2017-07-10 12:35:19.489458: I tensorflow/core/common_runtime/gpu/gpu_device.cc:940] Found device 0 with properties:
name: Tesla P100-PCIE-12GB
major: 6 minor: 0 memoryClockRate (GHz) 1.3285
pciBusID 0000:82:00.0
Total memory: 11.91GiB
Free memory: 11.63GiB
2017-07-10 12:35:19.491097: I tensorflow/core/common_runtime/gpu/gpu_device.cc:961] DMA: 0
2017-07-10 12:35:19.491156: I tensorflow/core/common_runtime/gpu/gpu_device.cc:971] 0:   Y
2017-07-10 12:35:19.520737: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Creating TensorFlow device (/gpu:0) -> (device: 0, name: Tesla P100-PCIE-12GB, pci bus id: 0000:82:00.0)
Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)
[3.0, 4.0]

TensorFlow fonctionne sur tous les types de nœuds GPU. Pour la recherche de grande envergure en apprentissage profond ou en apprentissage machine, il est fortement recommandé d'utiliser le type de nœuds GPU large de Cedar. Ces nœuds sont équipés de 4 x P100-PCIE-16Go avec GPUDirect P2P entre chaque paire. Pour plus d'information, consultez cette page.

Compatiblité du répertoire contrib

Calcul Canada compile des wheels pour obtenir la meilleure performance et ajouter des fonctionnalités qui ne sont pas disponibles dans les versions TensorFLow de Google. Certaines de ces fonctionnalités font partie du répertoire contrib de TensorFlow mais le soutien technique n'est pas dispensé officiellement par les développeurs de TensorFlow ni par Calcul Canada.

Le tableau suivant montre la compatibilité des fonctionnalités de contrib.

Version TensorFlow	GDR	VERBS	MPI
1.4.0	compilée, active	compilée, inactive	compilée, active
1.5.0	compilée, inactive	compilée, non testée	compilée, inactive
1.6.0	compilée, inactive	compilée, non testée	compilée, inactive
1.7.0	compilée, active	compilée, active	compilée, inactive
1.8.0	compilée, non testée	compilée, non testée	compilée, non testée

Pour faire ajouter une fonctionnalité dont vous avez besoin, contactez le soutien technique. Nous tenterons de recompiler TensorFlow en incluant la fonctionnalité.

Suivi

Il est possible de se connecter à un nœud sur lequel une tâche est en cours pour y exécuter des processus. On peut ainsi faire le suivi des ressources utilisées par TensorFlow et visualiser le déroulement de l'entraînement. Pour des exemples, consultez Surveillance d'une tâche en cours.

TensorBoard

TensorFlow propose la suite d'outils de visualisation TensorBoard qui lit les événements TensorFlow et modélise les fichiers. Pour savoir comment créer ces fichiers, consultez TensorBoard tutorial on summaries. Les fichiers d'événements sont créés dans le répertoire logdir spécifié par l'utilisateur.

Lancez TensorBoard.

[name@server ~]$ tensorboard --logdir=path/to/logdir --host 0.0.0.0

Sachez toutefois que TensorBoard exige trop de puissance de calcul pour être exécuté sur un nœud de connexion. Nous vous recommandons de l'exécuter en parallèle avec la tâche TensorFlow, comme dans l'exemple suivant. Le code source de mnist_with_summaries.py est disponible ici.

File : tensorboard.sh

#!/bin/bash
#SBATCH --gres=gpu:1        # request GPU "generic resource"
#SBATCH --cpus-per-task=6   # maximum CPU cores per GPU request: 6 on Cedar, 16 on Graham.
#SBATCH --mem=32000M        # memory per node
#SBATCH --time=01:00      # time (DD-HH:MM)

source tensorflow/bin/activate
tensorboard --logdir=/tmp/tensorflow/mnist/logs/mnist_with_summaries --host 0.0.0.0 &
python mnist_with_summaries.py

Pour accéder TensorBoard avec un fureteur une fois que la tâche est en cours, il faut créer un lien entre votre ordinateur et le nœud sur lequel TensorFlow et TensorBoard sont exécutés. Pour ce faire, vous avez besoin du hostname du nœud de calcul sur lequel le serveur TensorFlow se trouve; vous pouvez l'obtenir avec

[name@server ~]$ squeue --job JOBID -o %N

Pour créer cette connexion, utilisez la commande

[name@my_computer ~]$ ssh -N -f -L localhost:6006:computenode:6006 userid@cluster.computecanada.ca

Remplacez computenode par le hostname obtenu à l'étape précédente, userid par votre nom d'utilisateur Calcul Canada et, cluster par le hostname de la grappe (soit Cedar, Graham, etc.).

Une fois que la connexion est établie, allez à http://localhost:6006.

Utiliser plusieurs GPU

Il existe plusieurs méthodes de gestion des variables, les plus communes étant Parameter Server et Replicated.

• Nous allons utiliser ce code pour illustrer les diverses méthodes; vous pouvez l'adapter à vos besoins spécifiques.

Parameter Server

La copie maîtresse des variables est enregistrée sur un serveur de paramètres. En apprentissage distribué, les serveurs de paramètres sont des processus distincts dans chacun des appareils. À chaque étape, chacune des tours obtient du serveur de paramètres une copie des variables et y retourne ses gradients.

Les paramètres peuvent être enregistrés sur un CPU

python tf_cnn_benchmarks.py --variable_update=parameter_server --local_parameter_device=cpu

ou sur un GPU

python tf_cnn_benchmarks.py --variable_update=parameter_server --local_parameter_device=gpu

Replicated

Chaque GPU possède sa propre copie des variables. Les gradients sont copiés sur toutes les tours par aggrégation du contenu des appareils ou par un algorithme all reduce (dépendant de la valeur du paramètre all_reduce_spec).

Avec la méthode all reduce par défaut ː

python tf_cnn_benchmarks.py --variable_update=replicated

Xring --- utilisez un global ring reduction pour tous les tenseurs :

python tf_cnn_benchmarks.py --variable_update=replicated --all_reduce_spec=xring

Pscpu --- utilisez CPU at worker 0 pour réduire tous les tenseurs :

python tf_cnn_benchmarks.py --variable_update=replicated --all_reduce_spec=pscpu

NCCL --- utilisez NCCL pour réduire localement tous les tenseurs :

python tf_cnn_benchmarks.py --variable_update=replicated --all_reduce_spec=nccl

Les méthodes se comportent différemment selon les modèles; nous vous recommandons fortement de tester vos modèles avec toutes les méthodes sur les différents types de nœuds GPU.

Étalonnage (benchmarks)

Les résultats ont été obtenus avec TensorFlow v1.5 (CUDA9 et cuDNN 7) sur Graham et Cedar avec un seul GPU et plusieurs GPU et des méthodes différentes de gestion des variables; voyez TensorFlow Benchmarks.

• ResNet-50

Lots de 32 par GPU et parallélisation des données (les résultats sont en images par seconde).

Type de nœud	! GPU	Nombre de GPU	ps,cpu	ps, gpu	répliqué	répliqué, xring	répliqué, pscpu	répliqué, nccl
Graham, GPU base	171.23	2	93.31	324.04	318.33	316.01	109.82	315.99
Cedar GPU Base	172.99	4	662.65	595.43	616.02	490.03	645.04	608.95
Cedar, GPU Large	205.71	4	673.47	721.98	754.35	574.91	664.72	692.25

• VGG-16

Lots de 32 par GPU et parallélisation des données (les résultats sont en images par seconde).

Type de nœud	1 GPU	Nombre de GPU	ps,cpu	ps, gpu	répliqué	répliqué, xring	répliqué, pscpu	répliqué, nccl
Graham, GPU Base	115.89	2	91.29	194.46	194.43	203.83	132.19	219.72
Cedar, GPU Base	114.77	4	232.85	280.69	274.41	341.29	330.04	388.53
Cedar, GPU Large	137.16	4	175.20	379.80	336.72	417.46	225.37	490.52

Dépannage

scikit-image

Si vous utilisez la bibliothèque scikit-image, vous pourriez recevoir l'erreur OMP: Error #15: Initializing libiomp5.so, but found libiomp5.so already initialized.

Ceci se produit quand la bibliothèque TensorFlow essaie de charger une version de OMP incompatible avec la version. La commande suivante permet que l'installation utilise biomp5.so.

(tf_skimage_venv) name@server $ cd tf_skimage_venv
(tf_skimage_venv) name@server $ export LIBIOMP_PATH=$(strace python -c 'from skimage.transform import AffineTransform' 2>&1 | grep -v ENOENT | grep -ohP -e '(?<=")[^"]+libiomp5.so(?=")' | xargs realpath)
(tf_skimage_venv) name@server $ find -path '*_solib_local*' -name libiomp5.so -exec ln -sf $LIBIOMP_PATH {} \;

libcupti.so

Certaines fonctions de suivi de TensorFlow utilisent la bibliothèque libcupti.so; si cette dernière n'est pas disponible, l'erreur suivante pourrait survenir :

I tensorflow/stream_executor/dso_loader.cc:142] Couldn't open CUDA library libcupti.so.9.0. LD_LIBRARY_PATH: /usr/local/cuda-9.0/lib64

La solution est d'exécuter les commandes suivantes avant l'exécution du script.

[name@server ~]$ module load cuda/9.0.xxx
[name@server ~]$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CUDA_HOME/extras/CUPTI/lib64/

Remplacez xxx par la version appropriée de CUDA que vous pouvez trouver avec module av cuda.

libiomp5.so invalid ELF header

Le fichier objet partagé libiomp5.so est quelquefois par erreur installé en tant que fichier texte, ce qui peut produire des erreurs comme ceci :

/home/username/venv/lib/python3.6/site-packages/tensorflow/python/../../_solib_local/_U@mkl_Ulinux_S_S_Cmkl_Ulibs_Ulinux___Uexternal_Smkl_Ulinux_Slib/libiomp5.so: invalid ELF header

Pour solutionner ces erreurs, accédez au répertoire indiqué dans le message (soit [...]/_U@mkl_Ulinux_S_S_Cmkl_Ulibs_Ulinux___Uexternal_Smkl_Ulinux_Slib) et lancez la commande

[name@server ...Ulinux_Slib] $ ln -sf $(cat libiomp5.so) libiomp5.so

Le fichier texte sera remplacé par le bon lien symbolique.

Message Passing Interface