Compiler à partir de la source

Ce guide explique comment compiler un package pip TensorFlow à partir de la source et l'installer sur Ubuntu Linux et macOS. Bien que les instructions ci-dessous puissent fonctionner pour d'autres systèmes, elles ne sont testées et compatibles qu'avec Ubuntu et macOS.

Configuration pour Linux et macOS

Installez les outils de compilation suivants pour configurer votre environnement de développement.

Installer Python et les dépendances de package TensorFlow

sudo apt install python-dev python-pip  # or python3-dev python3-pip

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
brew install python@2  # or python (Python 3)

Installez les dépendances du package pip TensorFlow (si vous utilisez un environnement virtuel, omettez l'argument --user) :

pip install -U --user pip six numpy wheel setuptools mock 'future>=0.17.1'
pip install -U --user keras_applications --no-deps
pip install -U --user keras_preprocessing --no-deps

Installer Bazel

Pour compiler TensorFlow, vous devez installer Bazel. Bazelisk est un moyen simple d'installer Bazel. Il permet de télécharger automatiquement la version Bazel appropriée pour TensorFlow. Pour faciliter l'utilisation, ajoutez Bazelisk en tant qu'exécutable bazel dans votre variable PATH.

Si Bazelisk n'est pas disponible, vous pouvez l'installer manuellement. Veillez à installer une version compatible de Bazel, à savoir toute version comprise entre _TF_MIN_BAZEL_VERSION et _TF_MAX_BAZEL_VERSION, comme indiqué dans le fichier tensorflow/configure.py.

Installer la compatibilité GPU (facultatif, Linux uniquement)

La compatibilité GPU n'est pas proposée sous macOS.

Consultez le guide Compatibilité avec les GPU pour installer les pilotes et les logiciels supplémentaires requis pour exécuter TensorFlow sur un GPU.

Télécharger le code source de TensorFlow

Utilisez Git pour cloner le dépôt TensorFlow :

git clone https://github.com/tensorflow/tensorflow.git
cd tensorflow

Le dépôt est défini par défaut sur la branche de développement master. Vous pouvez également vous positionner sur une branche de publication pour effectuer la compilation :

git checkout branch_name  # r1.9, r1.10, etc.

Configurer la compilation

Configurez la compilation pour votre système en exécutant la commande ./configure à la racine de votre arborescence source TensorFlow. Le script vous invite à indiquer l'emplacement des dépendances TensorFlow et à définir des options de configuration de compilation supplémentaires (indicateurs de compilation, par exemple).

./configure

Exemple de session

Script ./configure. Voici un exemple d'exécution de ./configure (votre session peut se présenter différemment) :

./configure
You have bazel 0.15.0 installed.
Please specify the location of python. [Default is /usr/bin/python]: /usr/bin/python2.7

Found possible Python library paths:
  /usr/local/lib/python2.7/dist-packages
  /usr/lib/python2.7/dist-packages
Please input the desired Python library path to use.  Default is [/usr/lib/python2.7/dist-packages]

Do you wish to build TensorFlow with jemalloc as malloc support? [Y/n]:
jemalloc as malloc support will be enabled for TensorFlow.

Do you wish to build TensorFlow with Google Cloud Platform support? [Y/n]:
Google Cloud Platform support will be enabled for TensorFlow.

Do you wish to build TensorFlow with Hadoop File System support? [Y/n]:
Hadoop File System support will be enabled for TensorFlow.

Do you wish to build TensorFlow with Amazon AWS Platform support? [Y/n]:
Amazon AWS Platform support will be enabled for TensorFlow.

Do you wish to build TensorFlow with Apache Kafka Platform support? [Y/n]:
Apache Kafka Platform support will be enabled for TensorFlow.

Do you wish to build TensorFlow with XLA JIT support? [y/N]:
No XLA JIT support will be enabled for TensorFlow.

Do you wish to build TensorFlow with GDR support? [y/N]:
No GDR support will be enabled for TensorFlow.

Do you wish to build TensorFlow with VERBS support? [y/N]:
No VERBS support will be enabled for TensorFlow.

Do you wish to build TensorFlow with OpenCL SYCL support? [y/N]:
No OpenCL SYCL support will be enabled for TensorFlow.

Do you wish to build TensorFlow with CUDA support? [y/N]: Y
CUDA support will be enabled for TensorFlow.

Please specify the CUDA SDK version you want to use. [Leave empty to default to CUDA 9.0]: 9.0

Please specify the location where CUDA 9.0 toolkit is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:

Please specify the cuDNN version you want to use. [Leave empty to default to cuDNN 7.0]: 7.0

Please specify the location where cuDNN 7 library is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:

Do you wish to build TensorFlow with TensorRT support? [y/N]:
No TensorRT support will be enabled for TensorFlow.

Please specify the NCCL version you want to use. If NCLL 2.2 is not installed, then you can use version 1.3 that can be fetched automatically but it may have worse performance with multiple GPUs. [Default is 2.2]: 1.3

Please specify a list of comma-separated Cuda compute capabilities you want to build with.
You can find the compute capability of your device at: https://developer.nvidia.com/cuda-gpus
Please note that each additional compute capability significantly increases your
build time and binary size. [Default is: 3.5,7.0] 6.1

Do you want to use clang as CUDA compiler? [y/N]:
nvcc will be used as CUDA compiler.

Please specify which gcc should be used by nvcc as the host compiler. [Default is /usr/bin/gcc]:

Do you wish to build TensorFlow with MPI support? [y/N]:
No MPI support will be enabled for TensorFlow.

Please specify optimization flags to use during compilation when bazel option "--config=opt" is specified [Default is -march=native]:

Would you like to interactively configure ./WORKSPACE for Android builds? [y/N]:
Not configuring the WORKSPACE for Android builds.

Preconfigured Bazel build configs. You can use any of the below by adding "--config=<>" to your build command. See tools/bazel.rc for more details.
    --config=mkl            # Build with MKL support.
    --config=monolithic     # Config for mostly static monolithic build.
Configuration finished

Options de configuration

Compatibilité avec les GPU

Pour inclure la compatibilité avec les GPU, définissez cuda=Y lors de la configuration et spécifiez les versions de CUDA et cuDNN. Si plusieurs versions de CUDA ou de cuDNN sont installées sur votre système, définissez-la explicitement au lieu d'utiliser la version par défaut. La commande ./configure crée des liens symboliques vers les bibliothèques CUDA de votre système. Ainsi, si vous modifiez les chemins d'accès de votre bibliothèque CUDA, cette étape de configuration doit être exécutée à nouveau avant la compilation.

Optimisations

En ce qui concerne les indicateurs d'optimisation de la compilation, la valeur par défaut (-march=native) permet d'optimiser le code généré pour le type de processeur de votre machine. Cependant, si vous compilez TensorFlow pour un autre type de processeur, songez à utiliser un indicateur d'optimisation plus spécifique. Pour obtenir des exemples, consultez le manuel GCC.

Configurations prédéfinies

Certaines configurations de compilation prédéfinies peuvent être ajoutées à la commande bazel build, comme dans l'exemple suivant :

• --config=mkl : compatibilité pour la bibliothèque Intel® MKL-DNN.
• --config=monolithic : configuration pour une architecture principalement statique et monolithique.
• --config=v1 : compilation de TensorFlow 1.x au lieu de la version 2.x.

Créer le package pip

TensorFlow 2.x

Le dépôt tensorflow:master a été mis à jour pour la version 2.x. Installez Bazel et utilisez bazel build pour créer le package TensorFlow.

bazel build //tensorflow/tools/pip_package:build_pip_package

TensorFlow 1.x

Pour compiler la version 1.x de TensorFlow à partir de la branche master, utilisez bazel build --config=v1 pour créer un package TensorFlow 1.x.

bazel build --config=v1 //tensorflow/tools/pip_package:build_pip_package

Processeur uniquement

Utilisez bazel pour préparer le compilateur de packages TensorFlow compatible uniquement avec les processeurs :

bazel build --config=opt //tensorflow/tools/pip_package:build_pip_package

Compatibilité avec les GPU

Pour créer un package TensorFlow compatible avec les GPU, procédez comme suit :

bazel build --config=opt --config=cuda //tensorflow/tools/pip_package:build_pip_package

Options de compilation Bazel

Consultez la documentation de référence sur la ligne de commande Bazel pour connaître les options de compilation.

Compiler TensorFlow à partir de la source peut utiliser beaucoup de mémoire RAM. Si votre système dispose d'une mémoire RAM limitée, vous pouvez restreindre l'utilisation qu'en fait Bazel en ajoutant l'argument : --local_ram_resources=2048.

Les packages TensorFlow officiels sont créés avec une chaîne d'outils GCC 7.3 conforme à la spécification de package manylinux2010.

Pour GCC 5 et versions ultérieures, la compatibilité avec l'ancienne version ABI peut être ajoutée en utilisant l'argument suivant : --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0". L'interface binaire compatibilité (ABI) garantit que les opérations personnalisées créées avec le package TensorFlow officiel continuent de fonctionner avec le package GCC 5.

Créer le package

La commande bazel build crée un fichier exécutable intitulé build_pip_package. Il s'agit du programme qui permet de créer le package pip. Lancez le fichier exécutable comme indiqué ci-dessous pour créer un package .whl dans le répertoire /tmp/tensorflow_pkg.

Pour effectuer la compilation à partir d'une branche de publication, utilisez la commande suivante :

./bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

Pour effectuer la compilation à partir de la branche master, utilisez l'option --nightly_flag pour obtenir les dépendances appropriées :

./bazel-bin/tensorflow/tools/pip_package/build_pip_package --nightly_flag /tmp/tensorflow_pkg

Bien qu'il soit possible de créer des configurations CUDA et non-CUDA sous la même arborescence source, nous vous recommandons d'exécuter bazel clean lorsque vous passez de l'une à l'autre.

Installer le package

Le nom du fichier .whl généré dépend de la version de TensorFlow et de votre plate-forme. Installez le package à l'aide de pip install, comme dans l'exemple suivant :

pip install /tmp/tensorflow_pkg/tensorflow-version-tags.whl

Images Docker Linux

Les images de développement Docker de TensorFlow sont un moyen simple de configurer un environnement pour compiler des packages Linux à partir de la source. Elles contiennent déjà le code source et les dépendances nécessaires pour compiler TensorFlow. Consultez le guide Docker de TensorFlow pour obtenir des instructions d'installation et la liste des tags d'image disponibles.

Processeur uniquement

L'exemple suivant utilise l'image :devel pour créer un package Python 2 pour processeur uniquement à partir du code source TensorFlow le plus récent. Consultez le guide Docker pour obtenir la liste des tags TensorFlow -devel disponibles.

Téléchargez l'image de développement la plus récente et démarrez un conteneur Docker que vous utiliserez pour créer le package pip :

docker pull tensorflow/tensorflow:devel
docker run -it -w /tensorflow_src -v $PWD:/mnt -e HOST_PERMS="$(id -u):$(id -g)" \
    tensorflow/tensorflow:devel bash

git pull  # within the container, download the latest source code

La commande docker run ci-dessus démarre une interface système dans le répertoire /tensorflow_src, c'est-à-dire à la racine de l'arborescence source. Elle installe le répertoire actuel de l'hôte dans le répertoire /mnt du conteneur et transmet les informations de l'utilisateur hôte au conteneur à l'aide d'une variable d'environnement (utilisée pour définir les autorisations, tâche que Docker peut rendre difficile).

Pour créer une copie hôte de TensorFlow dans un conteneur, installez l'arborescence source de l'hôte dans le répertoire /tensorflow du conteneur :

docker run -it -w /tensorflow -v /path/to/tensorflow:/tensorflow -v $PWD:/mnt \
    -e HOST_PERMS="$(id -u):$(id -g)" tensorflow/tensorflow:devel bash

Une fois l'arborescence source configurée, créez le package TensorFlow dans l'environnement virtuel du conteneur :

1. Configurez la compilation. Vous serez invité à répondre à des questions sur la configuration de la compilation.
2. Compilez l'outil utilisé pour créer le package pip.
3. Exécutez l'outil pour créer le package pip.
4. Définissez les droits de propriété du fichier à l'extérieur du conteneur.

./configure  # answer prompts or use defaults

bazel build --config=opt //tensorflow/tools/pip_package:build_pip_package

./bazel-bin/tensorflow/tools/pip_package/build_pip_package /mnt  # create package

chown $HOST_PERMS /mnt/tensorflow-version-tags.whl

Installez et vérifiez le package dans le conteneur :

pip uninstall tensorflow  # remove current version

pip install /mnt/tensorflow-version-tags.whl
cd /tmp  # don't import from source directory
python -c "import tensorflow as tf; print(tf.__version__)"

Sur votre machine hôte, le package pip TensorFlow se trouve dans le répertoire actuel (avec les autorisations utilisateur hôte) : ./tensorflow-version-tags.whl

Compatibilité avec les GPU

Docker est le moyen le plus simple d'ajouter la compatibilité avec les GPU pour TensorFlow, puisque la machine hôte nécessite uniquement le pilote NVIDIA® (le NVIDIA® CUDA® Toolkit n'a pas besoin d'être installé). Consultez le guide sur la compatibilité avec les GPU et le guide Docker de TensorFlow pour configurer nvidia-docker (Linux uniquement).

L'exemple suivant télécharge l'image TensorFlow :devel-gpu-py3 et utilise nvidia-docker pour exécuter le conteneur compatible GPU. L'image de développement est configurée pour compiler un package pip Python 3 compatible avec les GPU :

docker pull tensorflow/tensorflow:devel-gpu-py3
docker run --gpus all -it -w /tensorflow -v $PWD:/mnt -e HOST_PERMS="$(id -u):$(id -g)" \
    tensorflow/tensorflow:devel-gpu-py3 bash
git pull  # within the container, download the latest source code

Ensuite, dans l'environnement virtuel du conteneur, compilez le package TensorFlow compatible GPU :

./configure  # answer prompts or use defaults

bazel build --config=opt --config=cuda //tensorflow/tools/pip_package:build_pip_package

./bazel-bin/tensorflow/tools/pip_package/build_pip_package /mnt  # create package

chown $HOST_PERMS /mnt/tensorflow-version-tags.whl

Installez et vérifiez le package dans le conteneur, puis recherchez un GPU :

pip uninstall tensorflow  # remove current version

pip install /mnt/tensorflow-version-tags.whl
cd /tmp  # don't import from source directory
python -c "import tensorflow as tf; print(tf.contrib.eager.num_gpus())"

Configurations de compilation testées

Linux

Processeur

GPU

macOS

Processeur

GPU