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

To build TensorFlow, you will need to install Bazel. Bazelisk is an easy way to install Bazel and automatically downloads the correct Bazel version for TensorFlow. For ease of use, add Bazelisk as the bazel executable in your 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 is a C/C++/Objective-C compiler that is compiled in C++ based on LLVM. It is the default compiler to build TensorFlow starting with TensorFlow 2.13. The current supported version is LLVM/Clang 17.

LLVM Debian/Ubuntu nightly packages provide an automatic installation script and packages for manual installation on Linux. Make sure you run the following command if you manually add llvm apt repository to your package sources:

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. Copy the extracted contents (directories and files) to /usr (you may need sudo permissions, and the correct directory may vary by distribution). This effectively installs Clang and LLVM, and adds it to the path. You should not have to replace anything, unless you have a previous installation, in which case you should replace the files:

   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.

Please run the ./configure script from the repository's root directory. This script will prompt you for the location of TensorFlow dependencies and asks for additional build configuration options (compiler flags, for example). Refer to the Sample session section for details.

./configure

There is also a python version of this script, ./configure.py . If using a virtual environment, python configure.py prioritizes paths within the environment, whereas ./configure prioritizes paths outside the environment. In both cases you can change the default.

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

For GPU support , set cuda=Y during configuration and specify the versions of CUDA and cuDNN if required. Bazel will download CUDA and CUDNN packages automatically or point to CUDA/CUDNN/NCCL redistributions on local file system if required.

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

For compilation optimization flags, the default ( -march=native ) optimizes the generated code for your machine's CPU type. However, if building TensorFlow for a different CPU type, consider a more specific optimization flag. Check the GCC manual for examples.

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

TensorFlow's Docker development images are an easy way to set up an environment to build Linux packages from source. These images already contain the source code and dependencies required to build TensorFlow. Go to the TensorFlow Docker guide for installation instructions and the list of available image tags .

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

The above docker run command starts a shell in the /tensorflow_src directory—the root of the source tree. It mounts the host's current directory in the container's /mnt directory, and passes the host user's information to the container through an environmental variable (used to set permissions—Docker can make this tricky).

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 is the easiest way to build GPU support for TensorFlow since the host machine only requires the NVIDIA® driver (the NVIDIA® CUDA® Toolkit doesn't have to be installed). Refer to the GPU support guide and the TensorFlow Docker guide to set up nvidia-docker (Linux only).

The following example downloads the TensorFlow :devel-gpu image and uses nvidia-docker to run the GPU-enabled container. This development image is configured to build a pip package with GPU support:

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