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 python3-dev python3-pip

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
export PATH="/usr/local/opt/python/libexec/bin:$PATH"
# if you are on macOS 10.12 (Sierra) use export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
brew install python

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

pip install -U --user pip numpy wheel
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  # r2.2, r2.3, 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

Si vous utilisez un environnement virtuel, la commande python configure.py donne la priorité aux chemins d'accès présents dans l'environnement, tandis que la commande ./configure priorise ceux en dehors de l'environnement. Dans les deux cas, vous pouvez modifier le paramètre par défaut.

Exemple de session

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

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

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

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 ROCm support? [y/N]:
No ROCm 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.

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

Found CUDA 10.1 in:
    /usr/local/cuda-10.1/targets/x86_64-linux/lib
    /usr/local/cuda-10.1/targets/x86_64-linux/include
Found cuDNN 7 in:
    /usr/lib/x86_64-linux-gnu
    /usr/include

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 Each capability can be specified as "x.y" or "compute_xy" to include both virtual and binary GPU code, or as "sm_xy" to only include the binary code.
Please note that each additional compute capability significantly increases your build time and binary size, and that TensorFlow only supports compute capabilities >= 3.5 [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]:

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

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 .bazelrc for more details.
    --config=mkl            # Build with MKL support.
    --config=monolithic     # Config for mostly static monolithic build.
    --config=ngraph         # Build with Intel nGraph support.
    --config=numa           # Build with NUMA support.
    --config=dynamic_kernels    # (Experimental) Build kernels into separate shared objects.
    --config=v2             # Build TensorFlow 2.x instead of 1.x.
Preconfigured Bazel build configs to DISABLE default on features:
    --config=noaws          # Disable AWS S3 filesystem support.
    --config=nogcp          # Disable GCP support.
    --config=nohdfs         # Disable HDFS support.
    --config=nonccl         # Disable NVIDIA NCCL support.
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=dbg  : compilation incluant des informations de débogage. Pour en savoir plus, consultez CONTRIBUTING.md.
• --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

Installez Bazel et utilisez bazel build pour créer le package TensorFlow 2.x avec la compatibilité du processeur uniquement :

bazel build [--config=option] //tensorflow/tools/pip_package:build_pip_package

Compatibilité avec les GPU

Pour créer un package TensorFlow avec la compatibilité GPU, procédez comme suit :

bazel build --config=cuda [--config=option] //tensorflow/tools/pip_package:build_pip_package

TensorFlow 1.x

Pour créer un package TensorFlow 1.x, utilisez l'option --config=v1 :

bazel build --config=v1 [--config=option] //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 de l'interface binaire d'application (ABI, Application Binary Interface) peut être ajoutée en utilisant l'argument suivant : --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0". La 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. Utilisez la commande pip install pour installer le package, 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 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 et utilise nvidia-docker pour exécuter le conteneur compatible GPU. L'image de développement est configurée pour compiler un package pip compatible avec les GPU :

docker pull tensorflow/tensorflow:devel-gpu
docker run --gpus all -it -w /tensorflow -v $PWD:/mnt -e HOST_PERMS="$(id -u):$(id -g)" \
    tensorflow/tensorflow:devel-gpu 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(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))"

Configurations de compilation testées

Linux

Processeur

GPU

macOS

Processeur

GPU