Como compilar o Tensorflow com as instruções SSE4.2 e AVX?

Esta é a mensagem recebida da execução de um script para verificar se o 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

Notei que ele mencionou SSE4.2 e AVX,

1. O que são SSE4.2 e AVX?
2. Como esses SSE4.2 e AVX melhoram os cálculos da CPU para tarefas do Tensorflow.
3. Como fazer o Tensorflow compilar usando as duas bibliotecas?

Acabei de encontrar o mesmo problema, parece que a sugestão de Yaroslav Bulatov não cobre o suporte ao SSE4.2, a adição --copt=-msse4.2seria suficiente. No final, eu construí com sucesso com

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

sem receber nenhum aviso ou erro.

Provavelmente, a melhor opção para qualquer sistema é:

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

( Atualização: os scripts de construção podem estar comendo-march=native , possivelmente porque contém um= .)

-mfpmath=bothsó funciona com gcc, não clang. -mfpmath=sseprovavelmente é tão bom, se não melhor, e é o padrão para x86-64. As versões de 32 bits são padrão para -mfpmath=387, portanto, alterar isso ajudará as de 32 bits. (Mas se você deseja alto desempenho para trituração de números, crie binários de 64 bits.)

Eu não tenho certeza do que padrão de TensorFlow para -O2ou -O3é. gcc -O3permite otimização completa, incluindo a vetorização automática, mas que às vezes pode tornar o código mais lento.

O que isso faz: --coptforbazel build passa uma opção diretamente para o gcc para compilar arquivos C e C ++ (mas não vincula, portanto, você precisa de uma opção diferente para otimização do tempo de link entre arquivos)

O x86-64 gcc usa como padrão apenas SSE2 ou instruções SIMD mais antigas, para que você possa executar os binários em qualquer sistema x86-64. (Consulte https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html ). Não é isso que você quer. Você quer criar um binário que tire proveito de todas as instruções que sua CPU pode executar, porque você só está executando esse binário no sistema em que o construiu.

-march=nativeativa todas as opções que sua CPU suporta, tornando-se -mavx512f -mavx2 -mavx -mfma -msse4.2redundante. (Além disso, -mavx2já habilita -mavxe -msse4.2, portanto, o comando de Yaroslav deveria estar bem). Além disso, se você estiver usando uma CPU que não suporta uma dessas opções (como FMA), o uso de -mfmaum binário falha com instruções ilegais.

O ./configurepadrão do TensorFlow é ativar-march=native , portanto, isso deve evitar a necessidade de especificar as opções do compilador manualmente.

-march=nativehabilita -mtune=native, otimizando sua CPU para coisas como qual sequência de instruções do AVX é melhor para cargas desalinhadas.

Isso tudo se aplica ao gcc, clang ou ICC. (Para ICC, você pode usar em -xHOSTvez de -march=native.)

Vamos começar com a explicação de por que você vê esses avisos em primeiro lugar .

Provavelmente você não instalou o TF a partir da fonte e, em vez disso, usou algo parecido pip install tensorflow. Isso significa que você instalou binários pré-criados (por outra pessoa) que não foram otimizados para sua arquitetura. E esses avisos dizem exatamente isso: algo está disponível em sua arquitetura, mas não será usado porque o binário não foi compilado com ele. Aqui está a parte da documentação .

O TensorFlow verifica na inicialização se ele foi compilado com as otimizações disponíveis na CPU. Se as otimizações não estiverem incluídas, o TensorFlow emitirá avisos, por exemplo, instruções AVX, AVX2 e FMA não incluídas.

O bom é que provavelmente você só quer aprender / experimentar o TF, para que tudo funcione corretamente e você não deve se preocupar com isso.

O que são SSE4.2 e AVX?

A Wikipedia tem uma boa explicação sobre SSE4.2 e AVX . Esse conhecimento não é necessário para ser bom em aprendizado de máquina. Você pode pensar nelas como um conjunto de instruções adicionais para um computador usar vários pontos de dados em uma única instrução para executar operações que podem ser naturalmente paralelizadas (por exemplo, adicionando duas matrizes).

O SSE e o AVX são a implementação de uma idéia abstrata de SIMD (instrução única, vários dados), que é

uma classe de computadores paralelos na taxonomia de Flynn. Ele descreve computadores com vários elementos de processamento que executam a mesma operação em vários pontos de dados simultaneamente. Assim, essas máquinas exploram o paralelismo no nível de dados, mas não a simultaneidade: há cálculos simultâneos (paralelos), mas apenas um único processo (instrução) em um determinado momento

Isso é suficiente para responder à sua próxima pergunta.

Como esses SSE4.2 e AVX melhoram os cálculos da CPU para tarefas de TF

Eles permitem um cálculo mais eficiente de várias operações de vetores (matriz / tensor). Você pode ler mais nesses slides

Como fazer o Tensorflow compilar usando as duas bibliotecas?

Você precisa ter um binário que foi compilado para tirar proveito dessas instruções. A maneira mais fácil é compilar você mesmo . Como Mike e Yaroslav sugeriram, você pode usar o seguinte comando 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

Deixe-me responder sua terceira pergunta primeiro:

Se você deseja executar uma versão auto-compilada dentro de um condda-env, é possível. Estas são as instruções gerais que eu corro para que o tensorflow seja instalado no meu sistema com instruções adicionais. Nota: Esta versão foi para uma versão AMD A10-7850 (verifique na sua CPU quais instruções são suportadas ... podem ser diferentes) executando o Ubuntu 16.04 LTS. Eu uso o Python 3.5 dentro do meu conda-env. O crédito vai para a página de instalação da fonte tensorflow e as respostas fornecidas acima.

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.

Quanto à sua segunda pergunta:

Uma versão auto-compilada com otimizações vale bem o esforço, na minha opinião. Na minha configuração específica, os cálculos que costumavam levar de 560 a 600 segundos agora levam apenas cerca de 300 segundos! Embora os números exatos variem, acho que você pode esperar um aumento de velocidade de 35 a 50% em geral em sua configuração específica.

Por fim, sua 1ª pergunta:

Muitas das respostas já foram fornecidas acima. Para resumir: AVX , SSE4.1, SSE4.2 , MFA são tipos diferentes de conjuntos de instruções estendidos em CPUs X86. Muitos contêm instruções otimizadas para o processamento de operações com matriz ou vetor.

Destacarei meu próprio conceito errôneo para poupar algum tempo: não é que o SSE4.2 seja uma versão mais recente das instruções que substituem o SSE4.1. SSE4 = SSE4.1 (um conjunto de 47 instruções) + SSE4.2 (um conjunto de 7 instruções).

No contexto da compilação do tensorflow, se o seu computador oferecer suporte ao AVX2 e AVX e SSE4.1 e SSE4.2, você deverá colocar esses sinalizadores de otimização para todos. Não faça como eu fiz e siga o SSE4.2 pensando que é mais novo e deve substituir o SSE4.1. Isso está claramente errado! Eu tive que recompilar por causa daquilo que me custou uns bons 40 minutos.

Estes são conjuntos de instruções de processamento de vetor SIMD .

O uso de instruções vetoriais é mais rápido para muitas tarefas; o aprendizado de máquina é uma tarefa dessas.

Citando os documentos de instalação do tensorflow :

Para ser compatível com o maior número possível de máquinas, o TensorFlow usa como padrão apenas as instruções SSE4.1 SIMD em máquinas x86. A maioria dos PCs e Macs modernos oferece suporte a instruções mais avançadas; portanto, se você estiver construindo um binário que estará executando apenas em sua própria máquina, poderá habilitá-los usando --copt=-march=nativeo comando bazel build.

Graças a todas essas respostas + algumas tentativas e erros, consegui instalá-lo em um Mac com clang. Então, basta compartilhar minha solução, caso seja útil para alguém.

1. Siga as instruções em Documentação - Instalando o TensorFlow a partir de fontes

2. Quando solicitado

   Especifique sinalizadores de otimização para usar durante a compilação quando a opção bazel "--config = opt" for especificada [O padrão é -march = native]

copie e cole esta sequência:

-mavx -mavx2 -mfma -msse4.2

(A opção padrão causou erros, o mesmo ocorreu com alguns dos outros sinalizadores. Não obtive erros com os sinalizadores acima. BTW, respondi na todas as outras perguntas)

Após a instalação, verifico uma aceleração de ~ 2x a 2,5x ao treinar modelos profundos em relação a outra instalação baseada nas rodas padrão - Instalação do TensorFlow no macOS

Espero que ajude

Eu o instalei recentemente a partir da fonte e abaixo estão todas as etapas necessárias para instalá-lo da fonte com as instruções mencionadas disponíveis.

Outras respostas já descrevem por que essas mensagens são mostradas. Minha resposta fornece um passo a passo de como instalar a instalação, o que pode ajudar as pessoas a se esforçarem na instalação real, como eu fiz.

1. Instale o Bazel

Faça o download de um de seus lançamentos disponíveis , por exemplo, 0.5.2 . Extraí-lo, vá para o diretório e configurá-lo: bash ./compile.sh. Copie o executável para /usr/local/bin:sudo cp ./output/bazel /usr/local/bin

2. Instale o Tensorflow

Clone tensorflow: git clone https://github.com/tensorflow/tensorflow.git Vá para o diretório clonado para configurá-lo:./configure

Irá solicitar várias perguntas, abaixo eu sugeri a resposta para cada uma das perguntas, é claro que você pode escolher suas próprias respostas conforme preferir:

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. O pacote pip. Para construí-lo, você deve descrever quais instruções deseja (você sabe, aquelas que o Tensorflow informou que estão faltando).

Crie 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

Crie o pacote pip: bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

Instale o pacote pip Tensorflow que você acabou de criar: sudo pip install /tmp/tensorflow_pkg/tensorflow-1.2.1-cp27-cp27mu-linux_x86_64.whl

Agora, da próxima vez que você iniciar o Tensorflow, ele não reclamará mais por falta de instruções.

Este é o método mais simples. Apenas um passo.

Tem um impacto significativo na velocidade. No meu caso, o tempo necessário para uma etapa de treinamento quase caiu pela metade.

Consulte construções personalizadas do fluxo tensor

Compilei um pequeno script Bash para Mac (facilmente pode ser portado para Linux) para recuperar todos os recursos da CPU e aplicar alguns deles para construir o TF. Estou no mestre do TF e uso meio frequentemente (algumas vezes em um mês).

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

Para compilar o TensorFlow com SSE4.2 e AVX, você pode usar diretamente

bazel build --config = mkl --config = "opt" --copt = "- march = broadwell" --copt = "- O3" // tensorflow / tools / pip_package: build_pip_package

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

2.0 SOLUÇÃO COMPATÍVEL:

Execute os comandos abaixo no Terminal (Linux / MacOS) ou no Prompt de Comando (Windows) para instalar o Tensorflow 2.0 usando o 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

Ao criar o TensorFlow a partir da fonte, você executará o configurescript. Uma das perguntas que o configurescript faz é a seguinte:

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

O configurescript anexará os sinalizadores que você especificar ao comando bazel que cria o pacote pip do TensorFlow. Em termos gerais, você pode responder a esse prompt de duas maneiras:

• Se você estiver construindo o TensorFlow no mesmo tipo de CPU que aquele em que executará o TensorFlow, deverá aceitar o padrão ( -march=native). Esta opção otimizará o código gerado para o tipo de CPU da sua máquina.
• Se você estiver construindo o TensorFlow em um tipo de CPU, mas executará o TensorFlow em um tipo de CPU diferente, considere fornecer um sinalizador de otimização mais específico, conforme descrito na documentação do gcc .

Após configurar o TensorFlow conforme descrito na lista com marcadores anterior, você poderá criar o TensorFlow totalmente otimizado para a CPU de destino apenas adicionando o --config=optsinalizador a qualquer comando bazel em execução.

Para ocultar esses avisos, você pode fazer isso antes do seu código real.

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