Compila con el código fuente

Compila un paquete pip de TensorFlow con el código fuente. Luego, instálalo en Linux Ubuntu y macOS. Si bien las instrucciones pueden funcionar en otros sistemas, solo se probaron en Ubuntu y macOS, y solo son compatibles con esos sistemas.

Configuración para Linux y macOS

Instala las siguientes herramientas de compilación para configurar tu entorno de desarrollo.

Instala Python y las dependencias del paquete de 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

Instala las dependencias del paquete pip de TensorFlow (si usas un entorno virtual, omite el argumento --user):

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

Instala Bazel

Para compilar TensorFlow, deberás instalar Bazel. Bazelisk es una forma sencilla de instalar Bazel y descargar automáticamente la versión de Bazel correcta para TensorFlow. Para que el proceso sea más sencillo, agrega Bazelisk como el archivo ejecutable bazel en tu PATH.

Si Bazelisk no está disponible, puedes instalar Bazel de forma manual. Asegúrate de instalar una versión compatible de Bazel: cualquier versión entre _TF_MIN_BAZEL_VERSION y _TF_MAX_BAZEL_VERSION, como se especifica en tensorflow/configure.py.

Instala la compatibilidad con GPU (opcional, solo para Linux)

No existe compatibilidad con GPU para macOS.

Lee la guía de compatibilidad con GPU para instalar los controladores y el software adicional necesarios para ejecutar TensorFlow en una GPU.

Descarga el código fuente de TensorFlow

Usa Git para clonar el repositorio de TensorFlow:

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

La configuración predeterminada del repositorio es la rama de desarrollo master. También puedes adquirir una rama de actualización para compilar:

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

Configura la compilación

Para configurar la compilación de tu sistema, ejecuta ./configure en la raíz del árbol fuente de TensorFlow. Esta secuencia de comandos te solicita la ubicación de las dependencias de TensorFlow y requiere opciones de configuración de compilación adicionales (por ejemplo, marcas del compilador).

./configure

Si usas un entorno virtual, python configure.py prioriza las rutas de acceso que se encuentran dentro del entorno, mientras que ./configure prioriza las que se encuentran fuera. En ambos casos, puedes cambiar el valor predeterminado.

Sesión de ejemplo

A continuación, se muestra un ejemplo de ejecución de ./configure (tu sesión puede 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

Opciones de configuración

Compatibilidad con GPU

Para conseguir la compatibilidad con GPU, establece cuda=Y durante la configuración y especifica las versiones de CUDA y cuDNN. Si tu sistema tiene varias versiones de CUDA o cuDNN, establece la versión de forma explícita en lugar de mantener la configuración predeterminada. ./configure crea vínculos simbólicos a las bibliotecas CUDA de tu sistema; por lo tanto, si actualizas las rutas de tu biblioteca CUDA, este paso de la configuración debe ejecutarse nuevamente antes de la compilación.

Optimizaciones

En el caso de las marcas de optimización de la compilación, el valor predeterminado (-march=native) optimiza el código generado para el tipo de CPU de tu máquina. Sin embargo, si compilas TensorFlow para un tipo de CPU diferente, te recomendamos utilizar una marca de optimización más específica. Para ver ejemplos, consulta el manual de GCC.

Configuraciones predefinidas

Existen algunas configuraciones de compilación predefinidas que se pueden agregar al comando bazel build, por ejemplo:

• --config=dbg: Compilar con información de depuración. Obtén más detalles en CONTRIBUTING.md
• --config=mkl: Compatibilidad con MKL-DNN de Intel®
• --config=monolithic: Configuración para una compilación mayormente estática y monolítica
• --config=v1: Compila TensorFlow 1.x en lugar de 2.x

Compila el paquete pip

TensorFlow 2.x

Instala Bazel y usa bazel build para crear el paquete de TensorFlow 2.x con compatibilidad solo para CPU:

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

Compatibilidad con GPU

Para crear un compilador de paquetes de TensorFlow compatible con GPU:

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

TensorFlow 1.x

Para compilar un paquete de TensorFlow 1.x más antiguo, usa la opción --config=v1:

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

Opciones de compilación de Bazel

Consulta la referencia de la línea de comandos de Bazel para ver las opciones de compilación.

Es posible que la compilación de TensorFlow con el código fuente consuma mucha memoria RAM. Si tu sistema tiene restricciones de memoria, limita el uso de la memoria RAM de Bazel con: --local_ram_resources=2048.

Los paquetes oficiales de TensorFlow se compilan con una cadena de herramientas GCC 7.3 que cumple con el estándar de paquetes manylinux2010.

Para GCC 5 y versiones posteriores, la compatibilidad con la ABI anterior se puede compilar con --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0". La compatibilidad con la ABI garantiza que las operaciones personalizadas compiladas en el paquete oficial de TensorFlow continúen funcionando con el paquete compilado GCC 5.

Compila el paquete

El comando bazel build crea un archivo ejecutable llamado build_pip_package, que es el programa que compila el paquete pip. Para compilar un paquete .whl en el directorio /tmp/tensorflow_pkg, ejecuta el archivo como se muestra más abajo:

Para compilar desde una rama de la actualización:

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

Para compilar desde la instancia principal, usa --nightly_flag a fin de obtener las dependencias correctas:

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

Si bien es posible compilar configuraciones CUDA y no CUDA en el mismo árbol fuente, recomendamos ejecutar bazel clean cuando se alterna entre estas dos configuraciones en el mismo árbol fuente.

Instala el paquete

El nombre del archivo .whl que se generó depende de la versión de TensorFlow y de tu plataforma. Para instalar el paquete, usa pip install, por ejemplo:

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

Compilaciones de Docker en Linux

Las imágenes de desarrollo de Docker de TensorFlow son una manera fácil de configurar un entorno para compilar paquetes de Linux con el código fuente. Estas imágenes ya contienen el código fuente y las dependencias necesarias para compilar TensorFlow. Consulta la guía de Docker de TensorFlow para la instalación y la lista de etiquetas de imagen disponibles.

Solo para CPU

En el siguiente ejemplo, se usa la imagen :devel para compilar un paquete de Python 2 exclusivo para CPU usando el código fuente de TensorFlow más reciente. Consulta la guía de Docker para conocer las etiquetas -devel de TensorFlow disponibles.

Descarga la imagen de desarrollo más reciente e inicia un contenedor de Docker que se usará para compilar el paquete 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

El comando docker run anterior inicia una shell en el directorio /tensorflow_src, la raíz del árbol fuente. Además, monta el directorio actual del host en el directorio /mnt del contenedor y pasa la información del usuario del host al contenedor mediante una variable de entorno (se usa para establecer permisos; Docker puede dificultar este proceso).

Como alternativa, para compilar una copia del host de TensorFlow dentro de un contenedor, monta el árbol fuente del host en el directorio /tensorflow del contenedor:

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 el árbol fuente configurado, compila el paquete de TensorFlow en el entorno virtual del contenedor:

1. Configura la compilación: Esta acción le pide al usuario que responda preguntas de la configuración de compilación.
2. Compila la herramienta utilizada para crear el paquete pip.
3. Ejecuta la herramienta para crear el paquete pip.
4. Ajusta los permisos de propiedad del archivo fuera del contenedor.

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

Instala y verifica el paquete dentro del contenedor:

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

En tu máquina anfitrión, el paquete pip de TensorFlow se encuentra en el directorio actual (con permisos del usuario del host): ./tensorflow-version-tags.whl

Compatibilidad con GPU

Docker es la forma más fácil de compilar la compatibilidad con GPU para TensorFlow, ya que la máquina anfitrión solo requiere el controlador de NVIDIA® (no es necesario instalar el kit de herramientas CUDA® de NVIDIA®). Consulta la guía de compatibilidad con GPU y la guía de Docker de TensorFlow para configurar nvidia-docker (solo para Linux).

El siguiente ejemplo descarga la imagen :devel-gpu de TensorFlow y usa nvidia-docker para ejecutar el contenedor habilitado para GPU. Esta imagen de desarrollo está configurada para compilar un paquete pip compatible con 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

Luego, dentro del entorno virtual del contenedor, compila el paquete de TensorFlow compatible con GPU:

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

Instala y verifica el paquete dentro del contenedor y busca 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')))"

Configuraciones de compilación probadas

Linux

CPU

GPU

macOS

CPU

GPU