TensorFlow/fr: Difference between revisions

From Alliance Doc
Jump to navigation Jump to search
(Updating to match new version of source page)
(Updating to match new version of source page)
Line 517: Line 517:


Le fichier texte sera remplacé par le bon lien symbolique.
Le fichier texte sera remplacé par le bon lien symbolique.
===libcudnn_adv_train.so.8 not found===
With TF 2.5, when using certain features, TF crashes with this message:
  Could not load library libcudnn_adv_train.so.8. Error: libcudnn_ops_train.so.8: cannot open shared object file: No such file or directory
  Please make sure libcudnn_adv_train.so.8 is in your library path!
This is a known issue and we are working on it. In the meantime, you can work around this issue by executing the following before launching your python program:
  module load gcc/9.3 cuda/11.1 cudnn/8.2
  export LD_LIBRARY_PATH=$EBROOTCUDNN/lib64:$LD_LIBRARY_PATH


==Contrôle du nombre de CPU et de fils==
==Contrôle du nombre de CPU et de fils==

Revision as of 19:12, 20 August 2021

Other languages:

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

Si vous voulez porter un programme TensorFlow sur un des superordinateurs de Calcul Canada, il serait bon de prendre connaissance du tutoriel sur le sujet.

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.

Chargez les modules requis par TensorFlow. 

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


Créez un nouvel environnement Python. 

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


Activez le nouvel environnement. 

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


Installez TensorFlow dans votre nouvel environnement virtuel en utilisant la commande suivante. 

(tensorflow) [name@server ~]$ pip install --no-index tensorflow==2.5

Chargez les modules requis par TensorFlow. TF 1.x requiert StdEnv/2018. 

[name@server ~]$ module load StdEnv/2018 python/3


Créez un nouvel environnement Python. 

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


Activez le nouvel environnement. 

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


Installez TensorFlow dans votre nouvel environnement virtuel en utilisant une des commandes suivantes, selon si vous avez besoin d'utiliser un GPU.

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==1.15.0


GPU

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


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)
node2 = tf.constant(4.0)
print(node1, node2)
print(node1 + node2)


File : tensorflow-test.py

import tensorflow as tf
node1 = tf.constant(3.0)
node2 = tf.constant(4.0)
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; il s'agit d'exemples de messages TensorFlow et il est possible que vous en ayez d'autres.

File : cdr116-122907.out

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)
tf.Tensor(3.0, shape=(), dtype=float32) tf.Tensor(4.0, shape=(), dtype=float32)
tf.Tensor(7.0, shape=(), dtype=float32)


File : cdr116-122907.out

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)
7.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.

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.

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 dans la même tâche que le processus TensorFlow. Pour ce faire, lancez TensorBoard en arrière-plan en l'appelant avant le script Python, en y ajoutant le caractère (&). 

# Your SBATCH arguments here

tensorboard --logdir=/tmp/your_log_dir --host 0.0.0.0 &
python train.py  # example

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. Pour le trouver, faites afficher la liste de vos tâches avec la commande sq et repérez la tâche; le hostname est la valeur qui se trouve dans la colonne NODELIST.

Pour créer la connexion, lancez la commande sur votre ordinateur local. 

[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 beluga, 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.

TensorFlow 1.x

TensorFlow provides different methods of managing variables when training models on multiple GPUs. "Parameter Server" and "Replicated" are the most two common methods.

  • In this section, TensorFlow Benchmarks code will be used as an example to explain the different methods. Users can reference the TensorFlow Benchmarks code to implement their own.

Parameter Server

Variables are stored on a parameter server that holds the master copy of the variable. In distributed training, the parameter servers are separate processes in the different devices. For each step, each tower gets a copy of the variables from the parameter server, and sends its gradients to the param server.

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 agré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 1 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

TensorFlow 2.x

Much like TensorFlow 1.x, TensorFlow 2.x offers a number of different strategies to make use of multiple GPUs through the high-level API tf.distribute. In the following sections, we provide code examples of each strategy using Keras for simplicity. For more details, please refer to the official TensorFlow documentation.

Mirrored Strategy

Single Node
File : tensorflow-singleworker.sh

#!/bin/bash
#SBATCH --nodes 1
#SBATCH --gres=gpu:4

#SBATCH --mem=8G      
#SBATCH --time=0-00:30
#SBATCH --output=%N-%j.out

module load python/3
virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate
pip install --no-index tensorflow

export NCCL_BLOCKING_WAIT=1  #Set this environment variable if you wish to use the NCCL backend for inter-GPU communication.

srun python tensorflow-singleworker.py


The Python script tensorflow-singleworker.py has the form:

File : tensorflow-singleworker.py

import tensorflow as tf
import numpy as np

import argparse


parser = argparse.ArgumentParser(description='cifar10 classification models, tensorflow MirroredStrategy test')
parser.add_argument('--lr', default=0.1, help='')
parser.add_argument('--batch_size', type=int, default=256, help='')

args = parser.parse_args()

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():

    model = tf.keras.Sequential()

    model.add(tf.keras.layers.Conv2D(32, (3, 3), padding='same',
                 input_shape=(32,32,3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Conv2D(32, (3, 3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
    model.add(tf.keras.layers.Dropout(0.25))

    model.add(tf.keras.layers.Conv2D(64, (3, 3), padding='same'))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Conv2D(64, (3, 3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
    model.add(tf.keras.layers.Dropout(0.25))

    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(512))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Dropout(0.5))
    model.add(tf.keras.layers.Dense(10))

    model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
         optimizer=tf.keras.optimizers.SGD(learning_rate=args.lr),metrics=['accuracy'])

### This next line will attempt to download the CIFAR10 dataset from the internet if you don't already have it stored in ~/.keras/datasets. 
### Run this line on a login node prior to submitting your job, or manually download the data from 
### https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz, rename to "cifar-10-batches-py.tar.gz" and place it under ~/.keras/datasets

(x_train, y_train),_ = tf.keras.datasets.cifar10.load_data()

dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(args.batch_size)

model.fit(dataset, epochs=2)


Multiple Nodes

The syntax to use multiple GPUs distributed across multiple nodes is very similar to the single node case, the most notable difference being the use of MultiWorkerMirroredStrategy(). Here, we use SlurmClusterResolver() to tell TensorFlow to acquire all the necessary job information from SLURM, instead of manually assigning master and worker nodes, for example. We also need to add CommunicationImplementation.NCCL to the distribution strategy to specify that we want to use Nvidia's NCCL backend for inter-GPU communications. This was not necessary in the single-node case, as NCCL is the default backend with MirroredStrategy().


File : tensorflow-multiworker.sh

#!/bin/bash
#SBATCH --nodes 2              # Request 2 nodes so all resources are in two nodes.
#SBATCH --gres=gpu:2          # Request 2 GPU "generic resources”. You will get 2 per node.

#SBATCH --tasks-per-node=2   # Request 1 process per GPU. You will get 1 CPU per process by default. Request more CPUs with the "cpus-per-task" parameter if your input pipeline can handle parallel data-loading/data-transforms

#SBATCH --mem=8G      
#SBATCH --time=0-00:30
#SBATCH --output=%N-%j.out


module load python/3
virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate
pip install --no-index tensorflow

export NCCL_BLOCKING_WAIT=1  #Set this environment variable if you wish to use the NCCL backend for inter-GPU communication.

srun python tensorflow-multiworker.py


The Python script tensorflow-multiworker.py has the form:

File : tensorflow-multiworker.py

import tensorflow as tf
import numpy as np

import argparse


parser = argparse.ArgumentParser(description='cifar10 classification models, tensorflow MultiWorkerMirrored test')
parser.add_argument('--lr', default=0.1, help='')
parser.add_argument('--batch_size', type=int, default=256, help='')

args = parser.parse_args()

cluster_config = tf.distribute.cluster_resolver.SlurmClusterResolver()
comm_options = tf.distribute.experimental.CommunicationOptions(implementation=tf.distribute.experimental.CommunicationImplementation.NCCL)

strategy = tf.distribute.MultiWorkerMirroredStrategy(cluster_resolver=cluster_config, communication_options=comm_options)

with strategy.scope():

    model = tf.keras.Sequential()

    model.add(tf.keras.layers.Conv2D(32, (3, 3), padding='same',
                 input_shape=(32,32,3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Conv2D(32, (3, 3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
    model.add(tf.keras.layers.Dropout(0.25))

    model.add(tf.keras.layers.Conv2D(64, (3, 3), padding='same'))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Conv2D(64, (3, 3)))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
    model.add(tf.keras.layers.Dropout(0.25))

    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(512))
    model.add(tf.keras.layers.Activation('relu'))
    model.add(tf.keras.layers.Dropout(0.5))
    model.add(tf.keras.layers.Dense(10))

    model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
         optimizer=tf.keras.optimizers.SGD(learning_rate=args.lr),metrics=['accuracy'])

### This next line will attempt to download the CIFAR10 dataset from the internet if you don't already have it stored in ~/.keras/datasets. 
### Run this line on a login node prior to submitting your job, or manually download the data from 
### https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz, rename to "cifar-10-batches-py.tar.gz" and place it under ~/.keras/datasets

(x_train, y_train),_ = tf.keras.datasets.cifar10.load_data()

dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(args.batch_size)

model.fit(dataset, epochs=2)


Opérateurs personnalisés

Dans le cadre de votre recherche, vous pourriez avoir besoin d'utiliser du code pour tirer avantage des opérateurs personnalisés qui ne sont pas inclus dans les distributions de TensorFlow, ou même vouloir créer vos propres opérateurs personnalisés. Dans les deux cas, vos opérateurs personnalisés doivent être compilés avant que vous soumettiez la tâche. Suivez les étapes ci-dessous.

Créez d'abord un environnement virtuel Python et installez une version de TensorFlow compatible avec vos opérateurs personnalisés. Allez ensuite au répertoire qui contient le code source des opérateurs et utilisez les commandes qui suivent selon la version que vous avez installée.

TensorFlow <= 1.4.x

Si votre opérateur personnalisé peut prendre en charge un GPU : 

[name@server ~]$ module load cuda/<version>
[name@server ~]$ nvcc <operator>.cu -o <operator>.cu.o -c -O2 -DGOOGLE_CUDA=1 -x cu -Xcompiler -fPI
[name@server ~]$ g++ -std=c++11 <operator>.cpp <operator>.cu.o -o <operator>.so -shared -fPIC -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include -I/<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include/external/nsync/public -I /usr/local/cuda-<version>/include -lcudart -L /usr/local/cuda-<version>/lib64/


Si votre opérateur personnalisé ne peut pas prendre en charge un GPU : 

[name@server ~]$ g++ -std=c++11 <operator>.cpp -o <operator>.so -shared -fPIC -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include -I/<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include/external/nsync/public


TensorFlow > 1.4.x

Si votre opérateur personnalisé peut prendre en charge un GPU : 

[name@server ~]$ module load cuda/<version>
[name@server ~]$ nvcc <operator>.cu -o <operator>.cu.o -c -O2 -DGOOGLE_CUDA=1 -x cu -Xcompiler -fPI
[name@server ~]$ g++ -std=c++11 <operator>.cpp <operator>.cu.o -o <operator>.so -shared -fPIC -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include -I /usr/local/cuda-<version>/include -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include/external/nsync/public -lcudart -L /usr/local/cuda-<version>/lib64/ -L /<path to python virtual env>/lib/python<version>/site-packages/tensorflow -ltensorflow_framework


Si votre opérateur personnalisé ne peut pas prendre en charge un GPU : 

[name@server ~]$ g++ -std=c++11 <operator>.cpp -o <operator>.so -shared -fPIC -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include -I /<path to python virtual env>/lib/python<version>/site-packages/tensorflow/include/external/nsync/public -L /<path to python virtual env>/lib/python<version>/site-packages/tensorflow -ltensorflow_framework


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

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

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

Contrôle du nombre de CPU et de fils

TensorFlow 1.x

Les paramètres de configuration device_count, intra_op_parallelism_threads et inter_op_parallelism_threads ont un effet sur le nombre de fils utilisés par TensorFlow; ces paramètres peuvent être définis comme suit à l'instanciation d'une session : 

tf.Session(config=tf.ConfigProto(device_count={'CPU': num_cpus}, intra_op_parallelism_threads=num_intra_threads, inter_op_parallelism_threads=num_inter_threads))

Si par exemple vous voulez exécuter plusieurs instances en parallèle dans un seul nœud, vous pourriez devoir utiliser de plus petites valeurs et même diminuer jusqu'à 1.

TensorFlow 2.x

Puisque les sessions ne sont plus utilisées, la configuration des fils se fait comme suit : 

tf.config.threading.set_inter_op_parallelism_threads(num_threads)
tf.config.threading.set_intra_op_parallelism_threads(num_threads)

Il ne semble pas possible de définir un nombre de CPU depuis la version 2.1.

Retrieved from "https://docs.alliancecan.ca/mediawiki/index.php?title=TensorFlow/fr&oldid=102989"