TensorFlow

From CC Doc
Jump to: navigation, search
This page is a translated version of the page Tensorflow and the translation is 60% complete.

Outdated translations are marked like this.
Other languages:
English • ‎français

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 paquets binaires (Python wheels) préparés par Calcul Canada; ces paquets se trouvent dans /cvmfs/soft.computecanada.ca/custom/python/wheelhouse/.
Le paquet TensorFlow sera installé dans un environment virtuel Python avec la commande pip.
Ces directives sont valides pour Python 3.5,; d'autres versions peuvent être installées en utilisant le module approprié.

Chargez les modules requis par TensorFlow.

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

Créez un nouvel environnement Python.

[name@server ~]$ virtualenv tensorflow

Activez le nouvel environnement.

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

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

Veillez à ne pas installer le paquet tensorflow (sans -cpu ou -gpu) car il existe des problèmes de compatibilité avec d'autres bibliothèques.

CPU seulement

(tensorflow)_[name@server ~]$ pip install tensorflow-cpu

GPU

(tensorflow)_[name@server ~]$ pip install tensorflow-gpu

R

To use TensorFlow in R, you will need to first follow the preceding instructions on creating a virtual environment and installing TensorFlow in it. Once this is done, following these instructions.

  1. Load the required modules :
    [name@server ~]$ module load gcc r/3.5.0
    
  2. Activate your Python virtual environment:
    [name@server ~]$ source tensorflow/bin/activate
    
  3. Launch R
    (tensorflow)_[name@server ~]$ R
    
  4. In R, install package devtools, then tensorflow:
    install.packages('devtools', repos='https://cloud.r-project.org')
    devtools::install_github('rstudio/tensorflow')
    

You are then good to go. Do not call install_tensorflow() in R, as TensorFlow has already been installed in your virtual environment with pip. To use the TensorFlow installed in your virtual environment, enter the following commands in R after the activation of the environment.

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 python/3.5.2
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.

Contrib compatiblity matrix

Compute Canada compiles TensorFlow wheels in order to get the maximum of performance and add features that are not available in Google's TensorFlow releases. Some of these features are part of the contrib folder of TensorFlow and are therefore not officially supported by TensorFlow developers, nor by Compute Canada staff. We try to accommodate as many users as possible by activating these features, but we are unable to provide support.

We present here a compatibility matrix of the contrib features we have compiled for each TensorFlow version and whether the feature is compiled, functional and has been tested.

TensorFlow Version GDR VERBS MPIMessage Passing Interface
1.4.0 compiled, functional compiled, untested compiled, functional
1.5.0 compiled, not functional compiled, untested compiled, not functional
1.6.0 compiled, not functional compiled, untested compiled, not functional
1.7.0 compiled, functional compiled, functional compiled, not functional
1.8.0 compiled, untested compiled, untested compiled, untested

If a contrib feature is missing in the version you use and you would like Compute Canada staff to try to integrate it, send your request to support@computecanada.ca. We will do our best to recompile TensorFlow with that feature activated.

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 la formation. 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 localhost

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 localhost &
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. Utilisez la commande

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

Si vous utilisez une version moins récente du client SSH, il se peut que l'option -J userid@cluster.computecanada.ca ne soit pas reconnue. Dans ce cas, utilisez plutôt la commande

[name@my_computer ~]$ ssh -o ProxyCommand="ssh -W %h:%p cluster.computecanada.ca" -N -f -L localhost:6006:localhost:6006 userid@compute_node

Remplacez

  • userid par votre nom d'utilisateur Calcul Canada,
  • cluster par le nom de la grappe (soit Cedar, Graham, etc.) et
  • computenode par le nom du nœud de calcul.
[name@server ~]$ squeue --job JOBID -o %N

To create that connection, use the following command:

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

Replace computenode with the node hostname you retrieved from the preceding step, userid by your Compute Canada username, cluster by the cluster hostname (i.e.: 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

Serveur de paramètres

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. To apply gradients, an all_reduce algorithm or or regular cross-device aggregation is used to replicate the combined gradients to all towers (depending on all_reduce_spec parameter setting).

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 avec les différents 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.

Benchmarks

This section will give ResNet-50 and VGG-16 benchmarking results pour TensorFlow v1.5 (CUDA9 et cuDNN 7) sur Graham et Cedar avec 1 seul GPU et plusieurs GPU et des méthodes différentes de gestion des variables. Les résultats se trouvent ici.

  • 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 Single GPU baseline Nombre de GPU ps,cpu ps, gpu replicated replicated, xring replicated, pscpu replicated, 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 Single GPU baseline Nombre de GPU ps,cpu ps, gpu replicated replicated, xring replicated, pscpu replicated, 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

Troubleshooting

scikit image

If you are using the scikit-image library, you may get the following error: OMP: Error #15: Initializing libiomp5.so, but found libiomp5.so already initialized.

This is because tensorflow library tries to load a bundled version of OMP which conflicts with the system version. The workaround is as follows:

  (tf_skimage_venv) name@server $ cd tf_skimage_venv
  (tf_skimage_venv) name@server $ 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 -wholename _solib_local -name libiomp5.so -exec ln -sf $LIBIOMP_PATH {} \;

This will patch the tensorflow library installation to use the systemwide libiomp5.so.

libcupti.so

Some tracing features of Tensorflow require libcupti.so to be available, and might give the following error if they are not:

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

The solution is to run the following before executing your script:

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

Where xxx is the appropriate CUDA version, which can be found using module av cuda