Crea dall'origine

Crea un pacchetto pip TensorFlow dal sorgente e installalo su Ubuntu Linux e macOS. Anche se le istruzioni potrebbero funzionare 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

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

pip install -U --user pip

Installa Bazel

Per creare TensorFlow, dovrai installare Bazel. Bazelisk è un modo semplice per installare Bazel e scarica automaticamente la versione Bazel corretta 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 corretta di Bazel dal file .bazelversion di TensorFlow.

Installa Clang (consigliato, solo Linux)

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

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

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

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

In alternativa, puoi scaricare e decomprimere il Clang + LLVM 17 precompilato.

Di seguito è riportato un esempio dei passaggi che è possibile eseguire per configurare i file 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 i contenuti estratti (directory e file) in /usr (potresti aver bisogno delle autorizzazioni sudo e la directory corretta può variare in base alla distribuzione). Questo installa effettivamente Clang e LLVM e lo 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. Controlla la versione dei binari Clang + LLVM 17 ottenuta:

   clang --version
   

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

Installa il supporto GPU (opzionale, solo Linux)

Non è disponibile il 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

Usa Git per clonare il repository TensorFlow :

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

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

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

Configura la build

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

Esegui lo script ./configure dalla directory root del repository. Questo script ti chiederà la posizione delle dipendenze di TensorFlow e richiederà 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 dà la priorità ai percorsi all'interno dell'ambiente, mentre ./configure dà la priorità ai percorsi all'esterno dell'ambiente. In entrambi i casi è possibile modificare l'impostazione predefinita.

Sessione di esempio

Di seguito viene mostrato un esempio di esecuzione dello script ./configure (la sessione potrebbe differire):

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

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

Ottimizzazioni

Per i flag di ottimizzazione della compilazione, il valore predefinito ( -march=native ) ottimizza il codice generato per il tipo di CPU della macchina. Tuttavia, se crei TensorFlow per un tipo di CPU diverso, considera 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 informazioni di debug. Vedi CONTRIBUTING.md per i dettagli.
• --config=mkl : supporto per Intel® MKL-DNN .
• --config=monolithic —Configurazione per una build prevalentemente statica e monolitica.

Compila e installa il pacchetto pip

Opzioni di costruzione Bazel

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

La creazione di TensorFlow dal sorgente può utilizzare molta RAM. Se il tuo sistema ha limiti di memoria, limita l'utilizzo della RAM di Bazel con: --local_ram_resources=2048 .

I pacchetti TensorFlow ufficiali 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, verrà creato il pacchetto, ad esempio:

Per creare il pacchetto CPU tensorflow:

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

Per creare il pacchetto GPU tensorflow:

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

Per creare il pacchetto TPU tensorflow:

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

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

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

Di conseguenza, la ruota generata verrà 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 tua piattaforma. Utilizzare pip install per installare il pacchetto, ad esempio:

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

Compilazione di Docker Linux

Le immagini di sviluppo Docker di TensorFlow rappresentano un modo semplice per configurare un ambiente per creare pacchetti Linux dal sorgente. Queste immagini contengono già il codice sorgente e le dipendenze necessarie per creare TensorFlow. Vai alla guida 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 dal codice sorgente TensorFlow più recente. Controlla la guida Docker per i tag TensorFlow -devel disponibili.

Scarica l'immagine di sviluppo più recente 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 dei sorgenti. Monta la directory corrente dell'host nella directory /mnt del contenitore e passa le informazioni dell'utente host al contenitore tramite una variabile ambientale (utilizzata per impostare le autorizzazioni: Docker può rendere la cosa complicata).

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

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

1. Facoltativo: configura la build: questo richiede all'utente di rispondere alle domande sulla configurazione della build.
2. Costruisci il pacchetto pip .
3. Modifica le autorizzazioni di proprietà del file per l'esterno del contenitore.

./configure  # if necessary

bazel build //tensorflow/tools/pip_package:wheel --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__)"

Sul computer host, il pacchetto pip TensorFlow si trova nella directory corrente (con le autorizzazioni dell'utente host): ./tensorflow- version - tags .whl

Supporto GPU

Docker è il modo più semplice per creare supporto GPU per TensorFlow poiché il computer host richiede solo il driver NVIDIA® (non è necessario installare NVIDIA® CUDA® Toolkit ). Fare riferimento alla guida al 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 contenitore, crea il pacchetto TensorFlow con supporto GPU:

./configure  # if necessary

bazel build //tensorflow/tools/pip_package:wheel --repo_env=WHEEL_NAME=tensorflow --config=cuda --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

Mac OS

processore

GPU