Créer à partir de la source

Compilez un paquet pip TensorFlow à partir des sources et installez-le sur Ubuntu Linux et macOS. Bien que la procédure puisse fonctionner sur d'autres systèmes, elle n'est testée et prise en charge que pour Ubuntu et macOS.

Configuration pour Linux et macOS

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

Installez 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

Installez Bazel

Pour compiler TensorFlow, vous devez installer Bazel. Bazelisk facilite l'installation de Bazel et télécharge automatiquement la version adaptée à TensorFlow. Pour plus de simplicité, ajoutez Bazelisk comme exécutable bazel à votre PATH .

Si Bazelisk n'est pas disponible, vous pouvez installer Bazel manuellement. Veillez à installer la version de Bazel appropriée à partir du fichier .bazelversion de TensorFlow.

Installez Clang (recommandé, Linux uniquement)

Clang est un compilateur C/C++/Objective-C compilé en C++ et basé sur LLVM. Il est le compilateur par défaut pour la compilation de TensorFlow depuis la version 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 apt llvm à vos sources de paquets :

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

Maintenant /usr/lib/llvm-17/bin/clang est le chemin d'accès réel à clang dans ce cas.

Vous pouvez également télécharger et décompresser le Clang + LLVM 17 précompilé.

Voici un exemple des étapes à suivre pour installer 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 droits sudo, et le répertoire exact peut varier selon votre distribution). Cela installera Clang et LLVM et les ajoutera au chemin d'accès. Vous ne devriez rien avoir à remplacer, sauf si vous avez déjà une installation ; dans ce 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 obtenus :

   clang --version

5. Le chemin d'accès à votre nouvelle installation de clang se trouve désormais dans /usr/bin/clang . Vous pouvez exécuter le script ./configure ou définir manuellement les variables d'environnement CC et BAZEL_COMPILER sur ce chemin.

Installer le support GPU (facultatif, Linux uniquement)

macOS ne prend pas en charge les GPU.

Consultez le guide de prise en charge des GPU pour installer les pilotes et les logiciels supplémentaires nécessaires à l'exécution de 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 utilise par défaut la branche de développement master . Vous pouvez également utiliser une branche de publication pour la compilation :

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

Configurer la version

La configuration des installations TensorFlow s'effectue via le fichier .bazelrc situé à la racine du dépôt. Les scripts ./configure ou ./configure.py permettent de modifier 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 supplémentaires (par exemple, des options de compilation). 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 privilégie les chemins situés à l’intérieur de cet environnement, tandis que ./configure privilégie les chemins situés à l’extérieur. Dans les deux cas, vous pouvez modifier le comportement par défaut.

Session d'exemple

L'exemple suivant illustre l'exécution du script ./configure (votre session peut différer) :

./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 indiquera l'emplacement des redistribuables CUDA/CUDNN/NCCL sur le système de fichiers local si nécessaire.

avant 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 plusieurs versions de CUDA ou cuDNN sont installées sur votre système, spécifiez explicitement la version au lieu d'utiliser la version par défaut. ./configure crée des liens symboliques vers les bibliothèques CUDA de votre système ; par conséquent, si vous modifiez les chemins d'accès à vos bibliothèques CUDA, cette étape de configuration doit être exécutée à nouveau avant la compilation.

Optimisations

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

Configurations préconfigurées

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

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

Compilez et installez le package pip

options de configuration Bazel

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

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 paquets officiels TensorFlow sont construits avec une chaîne d'outils Clang conforme à la norme de paquet manylinux2014.

Constituer le package

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

Pour compiler 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 un 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 un 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 nightly, définissez tf_nightly au lieu de tensorflow , par exemple pour créer un package nightly CPU :

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

Par conséquent, la roue générée sera située dans

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

Installez le package

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

Builds Docker Linux

Les images de développement Docker de TensorFlow permettent de configurer facilement un environnement pour compiler des paquets Linux à partir du code source. Ces images contiennent déjà le code source et les dépendances nécessaires à la compilation de TensorFlow. Consultez le guide Docker de TensorFlow pour obtenir les instructions d'installation et la liste des étiquettes d'image disponibles .

Processeur uniquement

L'exemple suivant utilise l'image :devel pour créer un package CPU uniquement à partir du code source TensorFlow le plus récent. Consultez le guide Docker pour connaître les étiquettes -devel de TensorFlow 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 permissions ; Docker peut rendre cette opération complexe).

Autre solution pour créer une copie hôte de TensorFlow dans un conteneur : monter l’arborescence source 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, compilez le package TensorFlow dans l'environnement virtuel du conteneur :

1. Facultatif : Configurer la compilation — cette option invite l’utilisateur à répondre à des questions de configuration de la compilation.
2. Créez le paquet pip .
3. Modifiez les autorisations de propriété du fichier pour les éléments situés en dehors 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 paquet 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 courant (avec les permissions de l'utilisateur hôte) ./tensorflow- version - tags .whl

Prise en charge du GPU

Docker est la méthode la plus simple pour activer la prise en charge GPU avec TensorFlow, car la machine hôte ne nécessite que le pilote NVIDIA® (le kit de développement NVIDIA® CUDA® n'a pas besoin d'être installé). Consultez le guide de prise en charge 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. Cette image de développement est configurée pour créer un paquet pip prenant en charge le 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 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 paquet dans le conteneur et vérifiez la présence d'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 compilation testées

Linux

processeur

GPU

macOS

processeur

GPU