Criar da origem

Crie um pacote PIP do TensorFlow a partir da origem e instale-o no Ubuntu Linux e macOS. Embora as instruções funcionem para outros sistemas, ele só é testado e compatível com o Ubuntu e o macOS.

Configuração para Linux e macOS

Instale as ferramentas de compilação a seguir para configurar o ambiente para desenvolvedores.

Instalar o Python e as dependências de pacote do 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

Instale o pacote de dependências PIP do TensorFlow (se estiver usando um ambiente virtual, omita o argumento --user):

pip install -U --user pip numpy wheel
pip install -U --user keras_preprocessing --no-deps

Instalar o Bazel

Para criar o TensorFlow, você precisará instalar o Bazel. O Bazelisk é uma maneira fácil de instalar o Bazel e fazer o download automático da versão correta do TensorFlow. Para facilitar o uso, adicione o Bazelisk como o executável bazel no seu PATH.

Se o Bazelisk não estiver disponível, você poderá instalar o Bazel manualmente. Certifique-se de instalar uma versão do Bazel compatível: qualquer versão entre _TF_MIN_BAZEL_VERSION e _TF_MAX_BAZEL_VERSION, conforme especificado em tensorflow/configure.py.

Instalar o suporte a GPUs (opcional, somente Linux)

Não há suporte a GPUs no macOS.

Leia o guia de suporte a GPUs para instalar os drivers e o software adicional necessário para executar o TensorFlow em uma GPU.

Fazer o download do código-fonte do TensorFlow

Use Git para clonar o repositório do TensorFlow:

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

O repositório tem como padrão a ramificação de desenvolvimento master. Você também pode conferir uma ramificação de lançamento para criar:

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

Configurar o build

Configure o build do sistema executando o ./configure na raiz da árvore de origem do TensorFlow. Esse script solicita o local das dependências do TensorFlow e também pede opções de configuração da compilação adicionais (sinalizações do compilador, por exemplo).

./configure

Se estiver usando um ambiente virtual, python configure.py prioriza caminhos dentro desse ambiente, enquanto ./configure prioriza caminhos fora dele. Nos dois casos, é possível modificar o padrão.

Sessão de exemplo

Veja a seguir um exemplo do script ./configure (sua sessão pode ser diferente):

./configure
You have bazel 3.0.0 installed.
Please specify the location of python. [Default is /usr/bin/python3]:

Found possible Python library paths:
  /usr/lib/python3/dist-packages
  /usr/local/lib/python3.6/dist-packages
Please input the desired Python library path to use.  Default is [/usr/lib/python3/dist-packages]

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

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]: Y
CUDA support will be enabled for TensorFlow.

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

Found CUDA 10.1 in:
    /usr/local/cuda-10.1/targets/x86_64-linux/lib
    /usr/local/cuda-10.1/targets/x86_64-linux/include
Found cuDNN 7 in:
    /usr/lib/x86_64-linux-gnu
    /usr/include

Please specify a list of comma-separated CUDA compute capabilities you want to build with.
You can find the compute capability of your device at: https://developer.nvidia.com/cuda-gpus Each capability can be specified as "x.y" or "compute_xy" to include both virtual and binary GPU code, or as "sm_xy" to only include the binary code.
Please note that each additional compute capability significantly increases your build time and binary size, and that TensorFlow only supports compute capabilities >= 3.5 [Default is: 3.5,7.0]: 6.1

Do you want to use clang as CUDA compiler? [y/N]:
nvcc will be used as CUDA compiler.

Please specify which gcc should be used by nvcc as the host compiler. [Default is /usr/bin/gcc]:

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

Would you like to interactively configure ./WORKSPACE for Android builds? [y/N]:
Not configuring the WORKSPACE for Android builds.

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=monolithic     # Config for mostly static monolithic build.
    --config=ngraph         # Build with Intel nGraph support.
    --config=numa           # Build with NUMA support.
    --config=dynamic_kernels    # (Experimental) Build kernels into separate shared objects.
    --config=v2             # Build TensorFlow 2.x instead of 1.x.
Preconfigured Bazel build configs to DISABLE default on features:
    --config=noaws          # Disable AWS S3 filesystem support.
    --config=nogcp          # Disable GCP support.
    --config=nohdfs         # Disable HDFS support.
    --config=nonccl         # Disable NVIDIA NCCL support.
Configuration finished

Opções de configuração

Suporte a GPUs

Para suporte a GPUs, defina cuda=Y durante a configuração e especifique as versões da CUDA e da cuDNN. Se o sistema tiver várias versões da CUDA ou da cuDNN instaladas, defina explicitamente a versão em vez de confiar no padrão. ./configure cria links simbólicos para as bibliotecas CUDA do sistema. Portanto, se você atualizar os caminhos da biblioteca CUDA, essa etapa de configuração precisará ser executada novamente antes da criação.

Otimizações

Para sinalizações de otimização de compilação, o padrão (-march=native) otimiza o código gerado para o tipo de CPU da sua máquina. No entanto, se estiver criando o TensorFlow para um tipo de CPU diferente, considere uma sinalização de otimização mais específica. Veja exemplos no manual do GCC.

Configurações predefinidas

Há algumas configurações de compilação predefinidas disponíveis que podem ser adicionadas ao comando bazel build, por exemplo:

• --config=dbg: crie com informações de depuração. Veja CONTRIBUTING.md para saber mais detalhes.
• --config=mkl: é compatível com Intel® MKL-DNN.
• --config=monolithic: é uma configuração para um build predominantemente estático e monolítico.
• --config=v1: crie o TensorFlow 1.x em vez do 2.x.

Criar o pacote PIP

TensorFlow 2.x

Instale o Bazel e use bazel build para criar o pacote do TensorFlow 2.x compatível somente com CPU:

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

Suporte a GPUs

Para criar um builder de pacote do TensorFlow com suporte para GPU:

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

TensorFlow 1.x

Para criar um pacote do TensorFlow 1.x mais antigo, use a opção --config=v1:

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

Opções de criação do Bazel

Veja a referência de linha de comando do Bazel para opções de build.

Criar o TensorFlow a partir da fonte pode usar muita memória RAM. Se o sistema tem restrições de memória, limite o uso de RAM do Bazel com: --local_ram_resources=2048.

Os pacotes oficiais do TensorFlow são criados com um conjunto de ferramentas GCC 7.3 que está em conformidade com o pacote padrão manylinux2010.

Para o GCC 5 e versões mais recentes, a compatibilidade com a ABI mais antiga pode ser criada usando: --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0". A compatibilidade com ABI garante que operações personalizadas criadas com o pacote oficial do TensorFlow continuem funcionando com o pacote de criação do GCC 5.

Criar o pacote

O comando bazel build cria um executável chamado build_pip_package. Esse é o programa que cria o pacote pip. Execute-o, conforme mostrado abaixo, para criar um pacote .whl no diretório /tmp/tensorflow_pkg.

Para criar a partir de uma ramificação de lançamento:

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

Para criar a partir do mestre, use --nightly_flag para receber as dependências corretas:

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

Embora seja possível criar configurações CUDA e não CUDA na mesma árvore de origem, é recomendável executar bazel clean ao fazer isso.

Instalar o pacote

O nome do arquivo .whl gerado depende da versão do TensorFlow e da sua plataforma. Use pip install para instalar o pacote, por exemplo:

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

Versões do Docker para Linux

As imagens de desenvolvimento do Docker do TensorFlow são uma maneira fácil de configurar um ambiente para criar pacotes do Linux a partir da fonte. Essas imagens já contêm o código-fonte e as dependências necessárias para criar o TensorFlow. Consulte o guia do Docker do TensorFlow para ver a instalação e a lista de tags de imagem disponíveis.

Somente CPU

O exemplo a seguir usa a imagem :devel para criar um pacote somente para CPU a partir do código-fonte mais recente do TensorFlow. Consulte o guia do Docker para ver as tags -devel do TensorFlow disponíveis.

Faça o download da imagem de desenvolvimento mais recente e inicie um contêiner do Docker que usaremos para criar o pacote 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

O comando docker run acima inicia um shell no diretório /tensorflow_src: a raiz da árvore de origem. Esse comando monta o diretório atual do host no diretório /mnt do contêiner e transmite as informações do usuário do host para o contêiner por uma variável de ambiente usada para definir permissões (o Docker pode tornar isso complicado).

Como alternativa, para criar uma cópia do host do TensorFlow em um contêiner, monte a árvore de origem do host no diretório /tensorflow do contêiner:

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

Com a árvore de origem configurada, crie o pacote do TensorFlow no ambiente virtual do contêiner:

1. Configure o build. Para isso o usuário precisa responder às perguntas de configuração da compilação.
2. Crie a ferramenta usada para criar o pacote PIP.
3. Execute a ferramenta para criar o pacote PIP.
4. Ajuste as permissões de propriedade do arquivo para fora do contêiner.

./configure  # answer prompts or use defaults

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

Instale e verifique o pacote no contêiner:

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

Na máquina host, o pacote PIP do TensorFlow está no diretório atual (com permissões de usuário do host): ./tensorflow-version-tags.whl

Suporte a GPUs

O Docker é a maneira mais fácil de criar suporte a GPUs para o TensorFlow, já que a máquina host requer apenas o driver NVIDIA®. O NVIDIA® CUDA® Toolkit não precisa ser instalado. Consulte o guia de suporte a GPUs e o guia do Docker do TensorFlow para configurar o nvidia-docker (somente Linux).

O exemplo a seguir faz o download da imagem :devel-gpu do TensorFlow e usa nvidia-docker para executar o contêiner ativado para GPU. Esta imagem de desenvolvimento está configurada para criar um pacote PIP com suporte a GPUs:

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

Em seguida, no ambiente virtual do contêiner, crie o pacote do TensorFlow com suporte a GPUs:

./configure  # answer prompts or use defaults

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

Instale e verifique o pacote no contêiner e verifique se há uma 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')))"

Configurações do build testadas

Linux

CPU

GPU

macOS

CPU

GPU