Créer à partir de la source

Créez un package pip TensorFlow à partir des sources et installez-le sur Ubuntu Linux et macOS. Bien que ces instructions puissent fonctionner sur d'autres systèmes, elles ne sont testées et prises en charge que sur Ubuntu et macOS.

Configuration pour Linux et macOS

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

Installer Python et les dépendances du package TensorFlow

sudo apt install python3-dev python3-pip

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

Installer Bazel

Pour créer TensorFlow, vous devez installer Bazel. Bazelisk est un moyen simple d'installer Bazel et télécharge automatiquement la version appropriée de Bazel pour TensorFlow. Pour plus de simplicité, ajoutez Bazelisk comme exécutable bazel dans votre PATH .

Si Bazelisk n'est pas disponible, vous pouvez installer Bazel manuellement. Assurez-vous d'installer la bonne version de Bazel depuis le fichier .bazelversion de TensorFlow.

Installer Clang (recommandé, Linux uniquement)

Clang est un compilateur C/C++/Objective-C compilé en C++ et basé sur LLVM. C'est le compilateur par défaut pour TensorFlow à partir de TensorFlow 2.13. La version actuellement prise en charge est LLVM/Clang 17.

Les paquets nocturnes LLVM pour Debian/Ubuntu fournissent un script d'installation automatique et des paquets pour une installation manuelle sous Linux. Assurez-vous d'exécuter la commande suivante si vous ajoutez manuellement le dépôt LLVM apt à vos sources de paquets :

sudo apt-get update && sudo apt-get install -y llvm-17 clang-17

Maintenant que /usr/lib/llvm-17/bin/clang est le chemin réel vers clang dans ce cas.

Alternativement, vous pouvez télécharger et décompresser le Clang + LLVM 17 pré-compilé.

Vous trouverez ci-dessous un exemple d'étapes que vous pouvez suivre pour configurer les binaires Clang + LLVM 17 téléchargés sur les systèmes d'exploitation Debian/Ubuntu :

1. Accédez au répertoire de destination souhaité : cd <desired directory>

2. Charger et extraire un fichier d'archive... (adapté à votre architecture) :

   wget https://github.com/llvm/llvm-project/releases/download/llvmorg-17.0.2/clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04.tar.xz
   
   tar -xvf clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04.tar.xz
   

3. Copiez le contenu extrait (répertoires et fichiers) dans /usr (vous aurez peut-être besoin des autorisations sudo, et le répertoire approprié peut varier selon la distribution). Cela installe Clang et LLVM et les ajoute au chemin d'accès. Vous ne devriez rien avoir à remplacer, sauf si vous disposez d'une installation précédente, auquel cas vous devrez remplacer les fichiers :

   cp -r clang+llvm-17.0.2-x86_64-linux-gnu-ubuntu-22.04/* /usr

4. Vérifiez la version des binaires Clang + LLVM 17 obtenue :

   clang --version

5. Maintenant que /usr/bin/clang est le chemin d'accès réel à votre nouveau clang, vous pouvez exécuter le script ./configure ou définir manuellement les variables d'environnement CC et BAZEL_COMPILER sur ce chemin.

Installer la prise en charge du GPU (facultatif, Linux uniquement)

Il n'y a pas de support GPU pour macOS.

Lisez le guide de support 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 référentiel TensorFlow :

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

Le dépôt utilise par défaut la branche de développement master . Vous pouvez également consulter une branche de publication pour compiler :

git checkout branch_name  # r2.2, r2.3, etc.

Configurer la construction

Les builds TensorFlow sont configurées par le fichier .bazelrc , situé dans le répertoire racine du dépôt. Les scripts ./configure ou ./configure.py permettent d'ajuster les paramètres courants.

Veuillez exécuter le script ./configure depuis le répertoire racine du dépôt. Ce script vous demandera l'emplacement des dépendances TensorFlow et des options de configuration de build supplémentaires (indicateurs de compilation, par exemple). Consultez la section « Exemple de session » pour plus de détails.

./configure

Il existe également une version Python de ce script : ./configure.py . Si vous utilisez un environnement virtuel, python configure.py priorise les chemins internes à l'environnement, tandis que ./configure priorise les chemins externes. Dans les deux cas, vous pouvez modifier la valeur par défaut.

Exemple de séance

Ce qui suit montre un exemple d'exécution du script ./configure (votre session peut être différente) :

./configure
You have bazel 6.1.0 installed.
Please specify the location of python. [Default is /Library/Frameworks/Python.framework/Versions/3.9/bin/python3]: 


Found possible Python library paths:
  /Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages
Please input the desired Python library path to use.  Default is [/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages]

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]:
No CUDA support will be enabled for TensorFlow.

Do you want to use Clang to build TensorFlow? [Y/n]:
Clang will be used to compile TensorFlow.

Please specify the path to clang executable. [Default is /usr/lib/llvm-16/bin/clang]:

You have Clang 16.0.4 installed.

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


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

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

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=mkl_aarch64    # Build with oneDNN and Compute Library for the Arm Architecture (ACL).
    --config=monolithic     # Config for mostly static monolithic build.
    --config=numa           # Build with NUMA support.
    --config=dynamic_kernels    # (Experimental) Build kernels into separate shared objects.
    --config=v1             # Build with TensorFlow 1 API instead of TF 2 API.
Preconfigured Bazel build configs to DISABLE default on features:
    --config=nogcp          # Disable GCP support.
    --config=nonccl         # Disable NVIDIA NCCL support.

Options de configuration

Prise en charge du GPU

à partir de la version 2.18.0

Pour la prise en charge du GPU , définissez cuda=Y lors de la configuration et spécifiez les versions de CUDA et cuDNN si nécessaire. Bazel téléchargera automatiquement les packages CUDA et CUDNN ou pointera vers les redistributions CUDA/CUDNN/NCCL sur le système de fichiers local si nécessaire.

avant la v.2.18.0

Pour la prise en charge GPU , définissez cuda=Y lors de la configuration et spécifiez les versions de CUDA et cuDNN. Si votre système possède plusieurs versions de CUDA ou cuDNN, définissez explicitement la version au lieu de vous fier à la version par défaut. ./configure crée des liens symboliques vers les bibliothèques CUDA de votre système. Ainsi, si vous mettez à jour les chemins de vos bibliothèques CUDA, cette étape de configuration doit être réexécutée avant la compilation.

Optimisations

Pour les options d'optimisation de la compilation, la valeur par défaut ( -march=native ) optimise le code généré pour le type de processeur de votre machine. Cependant, si vous compilez TensorFlow pour un autre type de processeur, envisagez une option d'optimisation plus spécifique. Consultez le manuel GCC pour des exemples.

Configurations préconfigurées

Il existe certaines configurations de build préconfigurées disponibles qui peuvent être ajoutées à la commande bazel build , par exemple :

• --config=dbg — Compilé avec les informations de débogage. Voir CONTRIBUTING.md pour plus de détails.
• --config=mkl — Prise en charge du Intel® MKL-DNN .
• --config=monolithic — Configuration pour une construction principalement statique et monolithique.

Construire et installer le package pip

Options de construction de Bazel

Reportez-vous à la référence de la ligne de commande Bazel pour les options de construction .

La compilation de TensorFlow à partir des sources peut consommer beaucoup de RAM. Si votre système est limité en mémoire, limitez l'utilisation de la RAM par Bazel avec : --local_ram_resources=2048 .

Les packages officiels TensorFlow sont construits avec une chaîne d'outils Clang conforme à la norme de package manylinux2014.

Construire le package

Pour créer un package pip, vous devez spécifier l'indicateur --repo_env=WHEEL_NAME . En fonction du nom fourni, le package sera créé, par exemple :

Pour créer le package CPU tensorflow :

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_cpu

Pour créer le package GPU tensorflow :

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow --config=cuda --config=cuda_wheel

Pour créer le package TPU tensorflow :

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_tpu --config=tpu

Pour créer un package nocturne, définissez tf_nightly au lieu de tensorflow , par exemple pour créer un package CPU nocturne :

bazel build //tensorflow/tools/pip_package:wheel --repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tf_nightly_cpu

En conséquence, la roue générée sera située dans

bazel-bin/tensorflow/tools/pip_package/wheel_house/

Installer le paquet

Le nom du fichier .whl généré dépend de la version de TensorFlow et de votre plateforme. Utilisez pip install pour installer le package, par exemple :

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

Versions Docker Linux

Les images de développement Docker de TensorFlow permettent de configurer facilement un environnement pour créer des packages Linux à partir des sources. Ces images contiennent déjà le code source et les dépendances nécessaires à la création de TensorFlow. Consultez le guide Docker de TensorFlow pour obtenir les instructions d'installation et la liste des balises d'image disponibles .

CPU uniquement

L'exemple suivant utilise l'image :devel pour créer un package dédié au processeur à partir du dernier code source TensorFlow. Consultez le guide Docker pour connaître les balises TensorFlow -devel disponibles.

Téléchargez la dernière image de développement 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 lance un shell dans le répertoire /tensorflow_src , la racine de l'arborescence source. Elle monte le répertoire courant de l'hôte dans le répertoire /mnt du conteneur et transmet les informations de l'utilisateur hôte au conteneur via une variable d'environnement (utilisée pour définir les autorisations, ce qui peut être complexe avec Docker).

Alternativement, pour créer une copie hôte de TensorFlow dans un conteneur, montez 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. Facultatif : Configurer la build : cela invite l’utilisateur à répondre aux questions de configuration de la build.
2. Construisez le package pip .
3. Ajustez les autorisations de propriété du fichier pour l'extérieur du conteneur.

./configure  # if necessary


bazel build //tensorflow/tools/pip_package:wheel \
--repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow_cpu --config=opt

`
chown $HOST_PERMS bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

Installez et vérifiez le package dans le conteneur :

pip uninstall tensorflow  # remove current version

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/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 de l'utilisateur hôte) : ./tensorflow- version - tags .whl

Prise en charge du GPU

Docker est le moyen le plus simple de prendre en charge le GPU pour TensorFlow, car la machine hôte ne nécessite que le pilote NVIDIA® (il n'est pas nécessaire d'installer NVIDIA® CUDA® Toolkit ). Consultez le guide de prise en charge du GPU et le guide TensorFlow Docker 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. Cette image de développement est configurée pour créer un package pip compatible 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, créez le package TensorFlow avec prise en charge GPU :

./configure  # if necessary


bazel build //tensorflow/tools/pip_package:wheel \
--repo_env=USE_PYWRAP_RULES=1 --repo_env=WHEEL_NAME=tensorflow --config=cuda \
--config=cuda_wheel --config=opt


chown $HOST_PERMS bazel-bin/tensorflow/tools/pip_package/wheel_house/tensorflow-version-tags.whl

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

pip uninstall tensorflow  # remove current version

pip install bazel-bin/tensorflow/tools/pip_package/wheel_house/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 build testées

Linux

processeur

GPU

macOS

processeur

GPU