Crea dall'origine

Crea un pacchetto pip TensorFlow dal codice sorgente e installalo su Ubuntu Linux e macOS. Sebbene le istruzioni possano funzionare anche per altri sistemi, sono testate e supportate solo per Ubuntu e macOS.

Configurazione per Linux e macOS

Installa i seguenti strumenti di compilazione per configurare il tuo ambiente di sviluppo.

Installa Python e le dipendenze del pacchetto TensorFlow

sudo apt install python3-dev python3-pip

brew install python

Installare le dipendenze del pacchetto pip di TensorFlow (se si utilizza un ambiente virtuale, omettere l'argomento --user ):

pip install -U --user pip

Installa Bazel

Per compilare TensorFlow, è necessario installare Bazel. Bazelisk è un modo semplice per installare Bazel e scarica automaticamente la versione corretta per TensorFlow. Per semplicità d'uso, aggiungi Bazelisk come eseguibile bazel nel tuo PATH .

Se Bazelisk non è disponibile, puoi installare Bazel manualmente. Assicurati di installare la versione corretta di Bazel dal file .bazelversion di TensorFlow.

Installa Clang (consigliato, solo per Linux)

Clang è un compilatore C/C++/Objective-C basato su LLVM, compilato in C++. È il compilatore predefinito per compilare TensorFlow a partire dalla versione 2.13. La versione attualmente supportata è LLVM/Clang 17.

I pacchetti nightly di LLVM per Debian/Ubuntu forniscono uno script di installazione automatica e pacchetti per l'installazione manuale su Linux. Assicurati di eseguire il seguente comando se aggiungi manualmente il repository apt di llvm alle tue sorgenti di pacchetti:

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

Ora, in questo caso /usr/lib/llvm-17/bin/clang è il percorso effettivo per clang.

In alternativa, puoi scaricare e decomprimere il pacchetto pre-costruito Clang + LLVM 17 .

Di seguito è riportato un esempio dei passaggi che è possibile seguire per configurare i binari Clang + LLVM 17 scaricati sui sistemi operativi Debian/Ubuntu:

1. Passare alla directory di destinazione desiderata: cd <desired directory>

2. Carica ed estrai un file di archivio...(adatto alla tua architettura):

   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. Copia il contenuto estratto (directory e file) in /usr (potrebbero essere necessari i permessi sudo e la directory corretta potrebbe variare a seconda della distribuzione). Questo installa effettivamente Clang e LLVM e li aggiunge al percorso. Non dovresti dover sostituire nulla, a meno che tu non abbia un'installazione precedente, nel qual caso dovresti sostituire i file:

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

4. Controllare la versione dei binari Clang + LLVM 17 ottenuti:

   clang --version

5. Ora che /usr/bin/clang è il percorso effettivo per il tuo nuovo clang, puoi eseguire lo script ./configure o impostare manualmente le variabili d'ambiente CC e BAZEL_COMPILER su questo percorso.

Installa il supporto GPU (facoltativo, solo Linux)

Non esiste alcun supporto GPU per macOS.

Leggi la guida al supporto GPU per installare i driver e il software aggiuntivo necessari per eseguire TensorFlow su una GPU.

Scarica il codice sorgente di TensorFlow

Utilizzare Git per clonare il repository TensorFlow :

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

Il repository è impostato di default sul ramo di sviluppo master . Puoi anche effettuare il check-out di un ramo di rilascio per compilare:

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

Configurare la build

Le build di TensorFlow sono configurate dal file .bazelrc nella directory principale del repository. Gli script ./configure o ./configure.py possono essere utilizzati per modificare le impostazioni comuni.

Eseguire lo script ./configure dalla directory principale del repository. Questo script richiederà la posizione delle dipendenze di TensorFlow e ulteriori opzioni di configurazione della build (ad esempio, flag del compilatore). Per i dettagli, consultare la sezione Sessione di esempio .

./configure

Esiste anche una versione Python di questo script, ./configure.py . Se si utilizza un ambiente virtuale, python configure.py dà priorità ai percorsi all'interno dell'ambiente, mentre ./configure dà priorità ai percorsi all'esterno dell'ambiente. In entrambi i casi è possibile modificare l'impostazione predefinita.

Sessione di esempio

Di seguito è riportato un esempio di esecuzione dello script ./configure (la sessione potrebbe essere diversa):

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

Opzioni di configurazione

Supporto GPU

dalla v.2.18.0

Per il supporto GPU , impostare cuda=Y durante la configurazione e specificare le versioni di CUDA e cuDNN, se necessario. Bazel scaricherà automaticamente i pacchetti CUDA e CUDNN o punterà alle ridistribuzioni CUDA/CUDNN/NCCL sul file system locale, se necessario.

prima della v.2.18.0

Per il supporto GPU , imposta cuda=Y durante la configurazione e specifica le versioni di CUDA e cuDNN. Se il sistema ha più versioni di CUDA o cuDNN installate, imposta esplicitamente la versione invece di basarti su quella predefinita. ./configure crea collegamenti simbolici alle librerie CUDA del sistema, quindi se aggiorni i percorsi delle librerie CUDA, questo passaggio di configurazione deve essere eseguito nuovamente prima della compilazione.

Ottimizzazioni

Per i flag di ottimizzazione della compilazione, l'impostazione predefinita ( -march=native ) ottimizza il codice generato per il tipo di CPU del computer. Tuttavia, se si compila TensorFlow per un tipo di CPU diverso, è consigliabile utilizzare un flag di ottimizzazione più specifico. Consultare il manuale di GCC per alcuni esempi.

Configurazioni preconfigurate

Sono disponibili alcune configurazioni di build preconfigurate che possono essere aggiunte al comando bazel build , ad esempio:

• --config=dbg — Compila con informazioni di debug. Vedi CONTRIBUTING.md per i dettagli.
• --config=mkl —Supporto per Intel® MKL-DNN .
• --config=monolithic —Configurazione per una build monolitica e prevalentemente statica.

Compila e installa il pacchetto pip

Opzioni di build Bazel

Per le opzioni di compilazione, fare riferimento al riferimento della riga di comando di Bazel.

Compilare TensorFlow dal codice sorgente può richiedere molta RAM. Se il sistema ha limitazioni di memoria, limita l'utilizzo della RAM di Bazel con: --local_ram_resources=2048 .

I pacchetti ufficiali di TensorFlow sono realizzati con una toolchain Clang conforme allo standard dei pacchetti manylinux2014.

Costruisci il pacchetto

Per creare un pacchetto pip, è necessario specificare il flag --repo_env=WHEEL_NAME . A seconda del nome fornito, il pacchetto verrà creato, ad esempio:

Per creare il pacchetto CPU tensorflow:

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

Per creare il pacchetto 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

Per creare il pacchetto TPU di tensorflow:

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

Per creare un pacchetto notturno, impostare tf_nightly invece di tensorflow , ad esempio per creare un pacchetto notturno CPU:

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

Di conseguenza, la ruota generata sarà posizionata in

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

Installa il pacchetto

Il nome del file .whl generato dipende dalla versione di TensorFlow e dalla piattaforma. Utilizza pip install per installare il pacchetto, ad esempio:

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

Build di Docker Linux

Le immagini di sviluppo Docker di TensorFlow rappresentano un modo semplice per configurare un ambiente per la creazione di pacchetti Linux a partire dal codice sorgente. Queste immagini contengono già il codice sorgente e le dipendenze necessarie per la creazione di TensorFlow. Consulta la guida Docker di TensorFlow per le istruzioni di installazione e l' elenco dei tag immagine disponibili .

Solo CPU

L'esempio seguente utilizza l'immagine :devel per creare un pacchetto CPU-only a partire dall'ultimo codice sorgente di TensorFlow. Consulta la guida Docker per i tag TensorFlow -devel disponibili.

Scarica l'ultima immagine di sviluppo e avvia un contenitore Docker che utilizzerai per creare il pacchetto 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

Il comando docker run sopra riportato avvia una shell nella directory /tensorflow_src , la radice dell'albero sorgente. Monta la directory corrente dell'host nella directory /mnt del container e passa le informazioni dell'utente host al container tramite una variabile d'ambiente (utilizzata per impostare i permessi, operazione che Docker può rendere complicata).

In alternativa, per creare una copia host di TensorFlow all'interno di un contenitore, montare l'albero sorgente dell'host nella directory /tensorflow del contenitore:

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

Dopo aver configurato l'albero sorgente, compila il pacchetto TensorFlow all'interno dell'ambiente virtuale del contenitore:

1. Facoltativo: configura la build: questa operazione richiede all'utente di rispondere alle domande sulla configurazione della build.
2. Compila il pacchetto pip .
3. Regola i permessi di proprietà del file per l'esterno del contenitore.

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

Installa e verifica il pacchetto all'interno del contenitore:

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__)"

Sulla macchina host, il pacchetto pip TensorFlow si trova nella directory corrente (con autorizzazioni utente host): ./tensorflow- version - tags .whl

Supporto GPU

Docker è il modo più semplice per creare il supporto GPU per TensorFlow, poiché la macchina host richiede solo il driver NVIDIA® (non è necessario installare NVIDIA® CUDA® Toolkit ). Consulta la guida al supporto GPU e la guida TensorFlow Docker per configurare nvidia-docker (solo Linux).

L'esempio seguente scarica l'immagine TensorFlow :devel-gpu e utilizza nvidia-docker per eseguire il contenitore abilitato per GPU. Questa immagine di sviluppo è configurata per creare un pacchetto pip con supporto 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

Quindi, all'interno dell'ambiente virtuale del contenitore, crea il pacchetto TensorFlow con supporto 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

Installa e verifica il pacchetto all'interno del contenitore e controlla la presenza di una 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')))"

Configurazioni di build testate

Linux

processore

GPU

macOS

processore

GPU