Costruisci dalla fonte

Crea un pacchetto pip TensorFlow dal sorgente e installalo su Ubuntu Linux e macOS. Mentre le istruzioni potrebbero funzionare per altri sistemi, è testato e supportato 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

/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

Installa le dipendenze del pacchetto pip di TensorFlow (se utilizzi un ambiente virtuale, ometti l'argomento --user ):

pip install -U --user pip numpy wheel packaging requests opt_einsum
pip install -U --user keras_preprocessing --no-deps

Installa Bazel

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

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

Installa il supporto GPU (facoltativo, solo Linux)

Non c'è supporto GPU per macOS.

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

Scarica il codice sorgente di TensorFlow

Usa Git per clonare il repository TensorFlow :

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

L'impostazione predefinita del repository è il ramo di sviluppo master . Puoi anche controllare un ramo di rilascio per creare:

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

Facoltativo: configurare il 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 regolare le impostazioni comuni.

Se è necessario modificare la configurazione, eseguire lo script ./configure dalla directory principale del repository. Questo script richiederà la posizione delle dipendenze di TensorFlow e richiede ulteriori opzioni di configurazione della build (flag del compilatore, ad esempio). Fare riferimento alla sezione Sessione di esempio per i dettagli.

./configure

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

Sessione campione

Quanto segue mostra un esempio di esecuzione dello script ./configure (la tua sessione potrebbe essere diversa):

./configure
You have bazel 5.0.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]: n
No ROCm support will be enabled for TensorFlow.

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

Do you wish to download a fresh release of clang? (Experimental) [y/N]: n
Clang will not be downloaded.

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


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

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

Ottimizzazioni

Per i flag di ottimizzazione della compilazione, il valore predefinito ( -march=native ) ottimizza il codice generato per il tipo di CPU della tua macchina. Tuttavia, se crei TensorFlow per un tipo di CPU diverso, prendi in considerazione un flag di ottimizzazione più specifico. Controlla il manuale GCC per esempi.

Configurazioni preconfigurate

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

• --config=dbg Crea con le informazioni di debug. Vedere CONTRIBUTING.md per i dettagli.
• --config=mkl mkl — Supporto per Intel® MKL-DNN .
• --config=monolithic monolytic — Configurazione per una build per lo più statica e monolitica.

Compila e installa il pacchetto pip

Il pacchetto pip è compilato in due fasi. Un bazel build crea un programma "costruttore di pacchetti". Quindi esegui il generatore di pacchetti per creare il pacchetto.

Costruisci il generatore di pacchetti

Usa bazel build per creare il generatore di pacchetti TensorFlow 2.x con supporto solo per CPU :

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

Supporto GPU

Per creare un generatore di pacchetti TensorFlow con supporto GPU:

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

Opzioni di costruzione Bazel

Fare riferimento al riferimento della riga di comando Bazel per le opzioni di compilazione .

La compilazione di TensorFlow dall'origine può utilizzare molta RAM. Se il tuo sistema è limitato dalla memoria, limita l'utilizzo della RAM di Bazel con: --local_ram_resources=2048 .

I pacchetti TensorFlow ufficiali sono costruiti con una toolchain GCC conforme allo standard dei pacchetti manylinux2010.

Per GCC 5 e versioni successive, la compatibilità con l'ABI precedente può essere creata utilizzando: --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0" . La compatibilità ABI garantisce che le operazioni personalizzate create con il pacchetto TensorFlow ufficiale continuino a funzionare con il pacchetto creato da GCC 5.

Costruisci il pacchetto

Il comando bazel build crea un eseguibile chiamato build_pip_package : questo è il programma che crea il pacchetto pip . Eseguire l'eseguibile come mostrato di seguito per creare un pacchetto .whl nella /tmp/tensorflow_pkg .

Per compilare da un ramo di rilascio:

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

Per costruire da master, usa --nightly_flag per ottenere le giuste dipendenze:

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

Sebbene sia possibile creare configurazioni CUDA e non CUDA nello stesso albero dei sorgenti, si consiglia di eseguire bazel clean quando si passa da una configurazione all'altra nello stesso albero dei sorgenti.

Installa il pacchetto

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

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

Build Docker Linux

Le immagini di sviluppo Docker di TensorFlow sono un modo semplice per configurare un ambiente per creare pacchetti Linux dall'origine. Queste immagini contengono già il codice sorgente e le dipendenze necessarie per creare TensorFlow. Vai alla guida di TensorFlow Docker 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 solo CPU dall'ultimo codice sorgente di TensorFlow. Consulta la guida di 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 precedente avvia una shell nella directory /tensorflow_src , la radice dell'albero di origine. Monta la directory corrente dell'host nella directory /mnt del contenitore e passa le informazioni dell'utente host al contenitore tramite una variabile ambientale (usata per impostare le autorizzazioni: Docker può complicare questa operazione).

In alternativa, per creare una copia host di TensorFlow all'interno di un contenitore, montare l'albero dei sorgenti 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

Con l'albero dei sorgenti configurato, crea il pacchetto TensorFlow all'interno dell'ambiente virtuale del contenitore:

1. Facoltativo: configurare la build: richiede all'utente di rispondere alle domande sulla configurazione della build.
2. Crea lo strumento utilizzato per creare il pacchetto pip .
3. Eseguire lo strumento per creare il pacchetto pip .
4. Regola le autorizzazioni di proprietà del file per l'esterno del contenitore.

./configure  # if necessary

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

Installa e verifica il pacchetto all'interno del contenitore:

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

Sul computer 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 ). Fare riferimento alla guida di supporto GPU e alla 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 container, crea il pacchetto TensorFlow con supporto GPU:

./configure  # if necessary

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

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

Configurazioni di build testate

Linux

processore

GPU

Mac OS

processore

GPU