¿Cómo compilar Tensorflow con las instrucciones SSE4.2 y AVX?

Este es el mensaje recibido al ejecutar un script para verificar si Tensorflow está funcionando:

I tensorflow/stream_executor/dso_loader.cc:125] successfully opened CUDA library libcublas.so.8.0 locally
I tensorflow/stream_executor/dso_loader.cc:125] successfully opened CUDA library libcudnn.so.5 locally
I tensorflow/stream_executor/dso_loader.cc:125] successfully opened CUDA library libcufft.so.8.0 locally
I tensorflow/stream_executor/dso_loader.cc:125] successfully opened CUDA library libcuda.so.1 locally
I tensorflow/stream_executor/dso_loader.cc:125] successfully opened CUDA library libcurand.so.8.0 locally
W tensorflow/core/platform/cpu_feature_guard.cc:95] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations.
W tensorflow/core/platform/cpu_feature_guard.cc:95] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations.
I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:910] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero

Noté que ha mencionado SSE4.2 y AVX,

1. ¿Qué son SSE4.2 y AVX?
2. ¿Cómo estos SSE4.2 y AVX mejoran los cálculos de la CPU para las tareas de Tensorflow?
3. ¿Cómo hacer que Tensorflow compile usando las dos bibliotecas?

Acabo de encontrarme con este mismo problema, parece que la sugerencia de Yaroslav Bulatov no cubre el soporte SSE4.2, --copt=-msse4.2lo suficiente sería suficiente. Al final, construí con éxito con

bazel build -c opt --copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-mfpmath=both --copt=-msse4.2 --config=cuda -k //tensorflow/tools/pip_package:build_pip_package

sin recibir ninguna advertencia o error.

Probablemente la mejor opción para cualquier sistema es:

bazel build -c opt --copt=-march=native --copt=-mfpmath=both --config=cuda -k //tensorflow/tools/pip_package:build_pip_package

( Actualización: los scripts de compilación pueden estar comiendo-march=native , posiblemente porque contiene un= .)

-mfpmath=bothsolo funciona con gcc, no clang. -mfpmath=ssees probablemente igual de bueno, si no mejor, y es el valor predeterminado para x86-64. Las compilaciones de 32 bits están predeterminadas en -mfpmath=387, por lo que cambiar eso ayudará a 32 bits. (Pero si desea un alto rendimiento para el procesamiento de números, debe crear binarios de 64 bits).

No estoy seguro de lo que por defecto de TensorFlow para -O2o -O3es. gcc -O3permite la optimización completa, incluida la vectorización automática, pero eso a veces puede hacer que el código sea más lento.

Lo que esto hace: --coptparabazel build pasa una opción directamente a gcc para compilar archivos de C y C ++ (pero no vincular, por lo que necesita una opción diferente para entre archivos de enlace en tiempo-optimización)

El valor predeterminado de x86-64 gcc es usar solo instrucciones SSE2 o SIMD anteriores, por lo que puede ejecutar los archivos binarios en cualquier sistema x86-64. (Ver https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html ). Eso no es lo que quieres. Desea crear un binario que aproveche todas las instrucciones que puede ejecutar su CPU, porque solo está ejecutando este binario en el sistema donde lo construyó.

-march=nativehabilita todas las opciones que admite su CPU, por lo que se vuelve -mavx512f -mavx2 -mavx -mfma -msse4.2redundante. (Además, -mavx2ya está habilitado -mavxy -msse4.2, por lo tanto, el comando de Yaroslav debería haber estado bien). Además, si está utilizando una CPU que no admite una de estas opciones (como FMA), el uso -mfmaharía un binario que falla con instrucciones ilegales.

El valor ./configurepredeterminado de TensorFlow es la habilitación-march=native , por lo que usar eso debería evitar tener que especificar las opciones del compilador manualmente.

-march=nativehabilita -mtune=native, por lo que se optimiza para su CPU para cosas como qué secuencia de instrucciones AVX es mejor para cargas no alineadas.

Todo esto se aplica a gcc, clang o ICC. (Para ICC, puede usar en -xHOSTlugar de -march=native).

Comencemos con la explicación de por qué ve estas advertencias en primer lugar .

Lo más probable es que no haya instalado TF desde la fuente y en lugar de eso haya usado algo como pip install tensorflow. Eso significa que instaló binarios pre-construidos (por otra persona) que no fueron optimizados para su arquitectura. Y estas advertencias le dicen exactamente esto: hay algo disponible en su arquitectura, pero no se usará porque el binario no se compiló con él. Aquí está la parte de la documentación .

TensorFlow comprueba en el inicio si se ha compilado con las optimizaciones disponibles en la CPU. Si las optimizaciones no están incluidas, TensorFlow emitirá advertencias, por ejemplo, las instrucciones AVX, AVX2 y FMA no incluidas.

Lo bueno es que lo más probable es que solo quieras aprender / experimentar con TF para que todo funcione correctamente y no debes preocuparte por eso

¿Qué son SSE4.2 y AVX?

Wikipedia tiene una buena explicación sobre SSE4.2 y AVX . Este conocimiento no es necesario para ser bueno en el aprendizaje automático. Puede pensar en ellos como un conjunto de algunas instrucciones adicionales para que una computadora use múltiples puntos de datos contra una sola instrucción para realizar operaciones que pueden estar paralelizadas naturalmente (por ejemplo, agregar dos matrices).

Tanto SSE como AVX son la implementación de una idea abstracta de SIMD (instrucción única, datos múltiples), que es

una clase de computadoras paralelas en la taxonomía de Flynn. Describe computadoras con múltiples elementos de procesamiento que realizan la misma operación en múltiples puntos de datos simultáneamente. Por lo tanto, tales máquinas explotan el paralelismo a nivel de datos, pero no la concurrencia: hay cálculos simultáneos (paralelos), pero solo un único proceso (instrucción) en un momento dado

Esto es suficiente para responder su próxima pregunta.

¿Cómo estos SSE4.2 y AVX mejoran los cálculos de CPU para las tareas de TF?

Permiten un cálculo más eficiente de varias operaciones de vectores (matriz / tensor). Puedes leer más en estas diapositivas

¿Cómo hacer que Tensorflow compile usando las dos bibliotecas?

Debe tener un binario que se compiló para aprovechar estas instrucciones. La forma más fácil es compilarlo usted mismo . Como sugirieron Mike y Yaroslav, puede usar el siguiente comando de bazel

bazel build -c opt --copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-mfpmath=both --copt=-msse4.2 --config=cuda -k //tensorflow/tools/pip_package:build_pip_package

Permítame responder su tercera pregunta primero:

Si desea ejecutar una versión autocompilada dentro de un conda-env, puede hacerlo. Estas son las instrucciones generales que ejecuto para que tensorflow se instale en mi sistema con instrucciones adicionales. Nota: Esta compilación fue para una compilación AMD A10-7850 (verifique en su CPU qué instrucciones son compatibles ... puede diferir) ejecutando Ubuntu 16.04 LTS. Yo uso Python 3.5 dentro de mi conda-env. El crédito va a la página de instalación de la fuente de tensorflow y las respuestas proporcionadas anteriormente.

git clone https://github.com/tensorflow/tensorflow 
# Install Bazel
# https://bazel.build/versions/master/docs/install.html
sudo apt-get install python3-numpy python3-dev python3-pip python3-wheel
# Create your virtual env with conda.
source activate YOUR_ENV
pip install six numpy wheel, packaging, appdir
# Follow the configure instructions at:
# https://www.tensorflow.org/install/install_sources
# Build your build like below. Note: Check what instructions your CPU 
# support. Also. If resources are limited consider adding the following 
# tag --local_resources 2048,.5,1.0 . This will limit how much ram many
# local resources are used but will increase time to compile.
bazel build -c opt --copt=-mavx --copt=-msse4.1 --copt=-msse4.2  -k //tensorflow/tools/pip_package:build_pip_package
# Create the wheel like so:
bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
# Inside your conda env:
pip install /tmp/tensorflow_pkg/NAME_OF_WHEEL.whl
# Then install the rest of your stack
pip install keras jupyter etc. etc.

En cuanto a su segunda pregunta:

Una versión autocompilada con optimizaciones bien vale la pena el esfuerzo en mi opinión. En mi configuración particular, ¡los cálculos que solían tomar 560-600 segundos ahora solo toman alrededor de 300 segundos! Aunque los números exactos variarán, creo que puede esperar un aumento de velocidad del 35-50% en general en su configuración particular.

Por último su primera pregunta:

Muchas de las respuestas ya se han proporcionado anteriormente. Para resumir: AVX , SSE4.1, SSE4.2 , MFA son diferentes tipos de conjuntos de instrucciones extendidas en las CPU X86. Muchos contienen instrucciones optimizadas para procesar operaciones de matriz u vectores.

Destacaré mi propio concepto erróneo para poder ahorrarle algo de tiempo: no es que SSE4.2 sea una versión más nueva de instrucciones que reemplacen a SSE4.1. SSE4 = SSE4.1 (un conjunto de 47 instrucciones) + SSE4.2 (un conjunto de 7 instrucciones).

En el contexto de la compilación de tensorflow, si su computadora es compatible con AVX2 y AVX, y SSE4.1 y SSE4.2, debe colocar esos indicadores de optimización para todos. No haga lo que hice y simplemente vaya con SSE4.2 pensando que es más nuevo y debería reemplazar a SSE4.1. Eso es claramente incorrecto! Tuve que volver a compilar debido a eso que me costó unos buenos 40 minutos.

Estos son conjuntos de instrucciones de procesamiento de vectores SIMD .

Usar instrucciones vectoriales es más rápido para muchas tareas; El aprendizaje automático es una tarea de este tipo.

Citando los documentos de instalación de tensorflow :

Para ser compatible con una gama de máquinas tan amplia como sea posible, TensorFlow solo usa las instrucciones SIME SSE4.1 en máquinas x86. La mayoría de las PC y Mac modernas admiten instrucciones más avanzadas, por lo que si está compilando un binario que solo ejecutará en su propia máquina, puede habilitarlas utilizando --copt=-march=nativesu comando de compilación bazel.

Gracias a todas estas respuestas + algunas pruebas y errores, logré instalarlo en una Mac con clang. Entonces, solo comparto mi solución en caso de que sea útil para alguien.

1. Siga las instrucciones en Documentación - Instalación de TensorFlow desde las fuentes

2. Cuando se le solicite

   Especifique los indicadores de optimización para usar durante la compilación cuando se especifica la opción "--config = opt" de Bazel [El valor predeterminado es -march = native]

luego copie y pegue esta cadena:

-mavx -mavx2 -mfma -msse4.2

(La opción predeterminada causó errores, al igual que algunos de los otros indicadores. No obtuve errores con los indicadores anteriores. Por cierto, respondí na todas las otras preguntas)

Después de la instalación, verifico una aceleración de ~ 2x a 2.5x cuando entreno modelos profundos con respecto a otra instalación basada en las ruedas predeterminadas - Instalación de TensorFlow en macOS

Espero eso ayude

Recientemente lo instalé desde la fuente y a continuación se detallan todos los pasos necesarios para instalarlo desde la fuente con las instrucciones mencionadas.

Otras respuestas ya describen por qué se muestran esos mensajes. Mi respuesta da un paso a paso sobre cómo instalar, lo que puede ayudar a las personas que luchan en la instalación real como lo hice yo.

1. Instalar Bazel

Descárguelo de uno de sus lanzamientos disponibles , por ejemplo 0.5.2 . Extraerlo, entra en el directorio y configurarlo: bash ./compile.sh. Copie el ejecutable a /usr/local/bin:sudo cp ./output/bazel /usr/local/bin

2. Instalar Tensorflow

Clonar tensorflow: git clone https://github.com/tensorflow/tensorflow.git vaya al directorio clonado para configurarlo:./configure

Le indicará varias preguntas. A continuación, he sugerido la respuesta a cada una de las preguntas, por supuesto, puede elegir sus propias respuestas como prefiera:

Using python library path: /usr/local/lib/python2.7/dist-packages
Do you wish to build TensorFlow with MKL support? [y/N] y
MKL support will be enabled for TensorFlow
Do you wish to download MKL LIB from the web? [Y/n] Y
Please specify optimization flags to use during compilation when bazel option "--config=opt" is specified [Default is -march=native]: 
Do you wish to use jemalloc as the malloc implementation? [Y/n] n
jemalloc disabled
Do you wish to build TensorFlow with Google Cloud Platform support? [y/N] N
No Google Cloud Platform support will be enabled for TensorFlow
Do you wish to build TensorFlow with Hadoop File System support? [y/N] N
No Hadoop File System support will be enabled for TensorFlow
Do you wish to build TensorFlow with the XLA just-in-time compiler (experimental)? [y/N] N
No XLA JIT support will be enabled for TensorFlow
Do you wish to build TensorFlow with VERBS support? [y/N] N
No VERBS support will be enabled for TensorFlow
Do you wish to build TensorFlow with OpenCL support? [y/N] N
No OpenCL 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

3. El paquete de pepitas. Para construirlo, debe describir qué instrucciones desea (ya sabe, esas Tensorflow le informaron que falta).

Construir script pip: bazel build -c opt --copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-mfpmath=both --copt=-msse4.1 --copt=-msse4.2 -k //tensorflow/tools/pip_package:build_pip_package

Construir paquete pip: bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

Instale el paquete pip Tensorflow que acaba de construir: sudo pip install /tmp/tensorflow_pkg/tensorflow-1.2.1-cp27-cp27mu-linux_x86_64.whl

Ahora, la próxima vez que inicie Tensorflow, ya no se quejará por la falta de instrucciones.

Este es el método más simple. Solo un paso.

Tiene un impacto significativo en la velocidad. En mi caso, el tiempo necesario para un paso de entrenamiento casi se redujo a la mitad.

Consulte las compilaciones personalizadas de tensorflow

Compilé un pequeño script de Bash para Mac (se puede portar fácilmente a Linux) para recuperar todas las funciones de la CPU y aplicar algunas de ellas para construir TF. Estoy en TF master y uso un poco a menudo (un par de veces en un mes).

https://gist.github.com/venik/9ba962c8b301b0e21f99884cbd35082f

Para compilar TensorFlow con SSE4.2 y AVX, puede usar directamente

compilación de bazel --config = mkl --config = "opt" --copt = "- march = broadwell" --copt = "- O3" // tensorflow / tools / pip_package: build_pip_package

Fuente: https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/docker/Dockerfile.devel-cpu-mkl

2.0 SOLUCIÓN COMPATIBLE:

Ejecute los siguientes comandos en Terminal (Linux / MacOS) o en el Símbolo del sistema (Windows) para instalar Tensorflow 2.0 usando Bazel :

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

#The repo defaults to the master development branch. You can also checkout a release branch to build:
git checkout r2.0

#Configure the Build => Use the Below line for Windows Machine
python ./configure.py 

#Configure the Build => Use the Below line for Linux/MacOS Machine
./configure
#This script prompts you for the location of TensorFlow dependencies and asks for additional build configuration options. 

#Build Tensorflow package

#CPU support
bazel build --config=opt //tensorflow/tools/pip_package:build_pip_package 

#GPU support
bazel build --config=opt --config=cuda --define=no_tensorflow_py_deps=true //tensorflow/tools/pip_package:build_pip_package

Al construir TensorFlow desde la fuente, ejecutará el configurescript. Una de las preguntas que hace el configureguión es la siguiente:

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

El configurescript adjuntará las banderas que especifique al comando bazel que construye el paquete de pip TensorFlow. En términos generales, puede responder a este mensaje de una de dos maneras:

• Si está compilando TensorFlow en el mismo tipo de CPU que con el que ejecutará TensorFlow, debe aceptar el valor predeterminado ( -march=native). Esta opción optimizará el código generado para el tipo de CPU de su máquina.
• Si está compilando TensorFlow en un tipo de CPU pero ejecutará TensorFlow en un tipo de CPU diferente, considere proporcionar un indicador de optimización más específico como se describe en la documentación de gcc .

Después de configurar TensorFlow como se describe en la lista con viñetas anterior, debería poder construir TensorFlow completamente optimizado para la CPU de destino simplemente agregando la --config=optbandera a cualquier comando de bazel que esté ejecutando.

Para ocultar esas advertencias, puede hacer esto antes de su código real.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
import tensorflow as tf