Come compilare Tensorflow con le istruzioni SSE4.2 e AVX?

Questo è il messaggio ricevuto dall'esecuzione di uno script per verificare se Tensorflow funziona:

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

Ho notato che ha menzionato SSE4.2 e AVX,

1. Cosa sono SSE4.2 e AVX?
2. In che modo questi SSE4.2 e AVX possono migliorare i calcoli della CPU per le attività di Tensorflow.
3. Come compilare Tensorflow usando le due librerie?

Ho appena incontrato questo stesso problema, sembra che il suggerimento di Yaroslav Bulatov non copra il supporto SSE4.2, l'aggiunta --copt=-msse4.2sarebbe sufficiente. Alla fine, ho costruito con successo

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

senza ricevere alcun avviso o errore.

Probabilmente la scelta migliore per qualsiasi sistema è:

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

( Aggiornamento: gli script di compilazione potrebbero non funzionare-march=native , probabilmente perché contiene un= .)

-mfpmath=bothfunziona solo con gcc, non clang. -mfpmath=sseè probabilmente altrettanto buono, se non migliore, ed è il valore predefinito per x86-64. Le build a 32 bit sono predefinite -mfpmath=387, quindi cambiando ciò aiuterà per 32 bit. (Ma se vuoi prestazioni elevate per lo scricchiolio dei numeri, dovresti creare binari a 64 bit.)

Non sono sicuro di quale sia l'impostazione predefinita di TensorFlow -O2o -O3. gcc -O3consente l'ottimizzazione completa, inclusa l'auto-vettorializzazione, ma a volte può rallentare il codice.

Cosa fa: --coptperbazel build passa un'opzione direttamente a gcc per la compilazione di file C e C ++ (ma non il collegamento, quindi è necessaria un'opzione diversa per l'ottimizzazione del tempo tra i collegamenti tra file)

gcc x86-64 utilizza automaticamente solo le istruzioni SIMD SSE2 o precedenti, quindi è possibile eseguire i binari su qualsiasi sistema x86-64. (Vedi https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html ). Non è quello che vuoi. Vuoi creare un binario che sfrutti tutte le istruzioni che la tua CPU può eseguire, perché stai eseguendo questo binario solo sul sistema in cui lo hai creato.

-march=nativeabilita tutte le opzioni supportate dalla CPU, quindi è -mavx512f -mavx2 -mavx -mfma -msse4.2ridondante. (Inoltre, -mavx2già abilita -mavxe -msse4.2, quindi il comando di Yaroslav avrebbe dovuto andare bene). Inoltre, se stai utilizzando una CPU che non supporta una di queste opzioni (come FMA), l'utilizzo -mfmacreerebbe un binario che guasta con istruzioni illegali.

L' ./configureimpostazione predefinita di TensorFlow è l' abilitazione-march=native , quindi l'utilizzo che dovrebbe evitare la necessità di specificare manualmente le opzioni del compilatore.

-march=nativeabilita -mtune=native, quindi ottimizza per la tua CPU per cose come quale sequenza di istruzioni AVX è la migliore per carichi non allineati.

Tutto questo vale per gcc, clang o ICC. (Per ICC, è possibile utilizzare -xHOSTinvece di -march=native.)

Cominciamo con la spiegazione del perché vedi questi avvisi in primo luogo .

Molto probabilmente non hai installato TF dal sorgente e invece hai usato qualcosa del genere pip install tensorflow. Ciò significa che hai installato binari precostruiti (da qualcun altro) che non sono stati ottimizzati per la tua architettura. E questi avvertimenti ti dicono esattamente questo: qualcosa è disponibile sulla tua architettura, ma non verrà usato perché il binario non è stato compilato con esso. Ecco la parte dalla documentazione .

TensorFlow verifica all'avvio se è stato compilato con le ottimizzazioni disponibili sulla CPU. Se le ottimizzazioni non sono incluse, TensorFlow emetterà avvisi, ad esempio istruzioni AVX, AVX2 e FMA non incluse.

La cosa buona è che molto probabilmente vuoi solo imparare / sperimentare con TF, quindi tutto funzionerà correttamente e non dovresti preoccuparti

Cosa sono SSE4.2 e AVX?

Wikipedia ha una buona spiegazione su SSE4.2 e AVX . Questa conoscenza non è richiesta per essere brava nell'apprendimento automatico. È possibile pensarli come un insieme di alcune istruzioni aggiuntive per un computer per utilizzare più punti dati rispetto a una singola istruzione per eseguire operazioni che possono essere naturalmente parallelizzate (ad esempio aggiungendo due array).

Sia SSE che AVX sono l'implementazione di un'idea astratta di SIMD (istruzione singola, dati multipli), che è

una classe di computer paralleli nella tassonomia di Flynn. Descrive i computer con più elementi di elaborazione che eseguono la stessa operazione su più punti dati contemporaneamente. Pertanto, tali macchine sfruttano il parallelismo a livello di dati, ma non la concorrenza: esistono calcoli (paralleli) simultanei, ma solo un singolo processo (istruzione) in un dato momento

Questo è sufficiente per rispondere alla tua prossima domanda.

In che modo questi SSE4.2 e AVX possono migliorare i calcoli della CPU per le attività TF

Consentono un calcolo più efficiente di varie operazioni vettoriali (matrice / tensore). Puoi leggere di più in queste diapositive

Come compilare Tensorflow usando le due librerie?

È necessario disporre di un file binario che è stato compilato per trarre vantaggio da queste istruzioni. Il modo più semplice è compilarlo da soli . Come suggerito da Mike e Yaroslav, puoi usare il seguente 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

Lasciami rispondere prima alla tua terza domanda:

Se vuoi eseguire una versione autocompilata in un conda-env, puoi farlo. Queste sono le istruzioni generali che eseguo per far installare tensorflow sul mio sistema con istruzioni aggiuntive. Nota: questa build era per una build AMD A10-7850 (controlla la tua CPU per quali istruzioni sono supportate ... potrebbe differire) con Ubuntu 16.04 LTS. Uso Python 3.5 nel mio conda-env. Il merito va alla pagina di installazione della fonte tensorflow e alle risposte fornite sopra.

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.

Per quanto riguarda la tua seconda domanda:

Una versione compilata con ottimizzazioni è valsa la pena secondo me. Nella mia configurazione particolare, i calcoli che impiegavano 560-600 secondi ora impiegano solo circa 300 secondi! Sebbene i numeri esatti possano variare, penso che ci si possa aspettare un aumento della velocità del 35-50% in generale sulla propria configurazione specifica.

Infine la tua prima domanda:

Molte delle risposte sono già state fornite sopra. Riassumendo: AVX , SSE4.1, SSE4.2 , MFA sono diversi tipi di set di istruzioni estese su CPU X86. Molti contengono istruzioni ottimizzate per l'elaborazione di operazioni a matrice o vettoriali.

Metterò in evidenza il mio malinteso per risparmiare un po 'di tempo: non è che SSE4.2 sia una versione più recente delle istruzioni che sostituiscono SSE4.1. SSE4 = SSE4.1 (un set di 47 istruzioni) + SSE4.2 (un set di 7 istruzioni).

Nel contesto della compilazione di tensorflow, se il tuo computer supporta AVX2 e AVX e SSE4.1 e SSE4.2, dovresti inserire tutti questi flag di ottimizzazione. Non fare come ho fatto io e andare con SSE4.2 pensando che è più recente e dovrebbe sostituire SSE4.1. È chiaramente SBAGLIATO! Ho dovuto ricompilare per quello che mi è costato 40 minuti buoni.

Questi sono set di istruzioni per l'elaborazione vettoriale SIMD .

L'uso di istruzioni vettoriali è più veloce per molte attività; l'apprendimento automatico è un compito del genere.

Citando i documenti di installazione di tensorflow :

Per essere compatibile con la più ampia gamma possibile di macchine, TensorFlow utilizza automaticamente le istruzioni SIMD SSE4.1 su macchine x86. La maggior parte dei PC e Mac moderni supporta istruzioni più avanzate, quindi se stai costruendo un binario che --copt=-march=nativeeseguirai solo sulla tua macchina, puoi abilitarli usando il comando bazel build.

Grazie a tutte queste risposte + alcune prove ed errori, sono riuscito a installarlo su un Mac con clang. Quindi, solo condividendo la mia soluzione nel caso sia utile a qualcuno.

1. Seguire le istruzioni sulla documentazione - Installazione di TensorFlow da fonti

2. Quando richiesto

   Specificare i flag di ottimizzazione da utilizzare durante la compilazione quando viene specificata l'opzione bazel "--config = opt" [L'impostazione predefinita è -march = native]

quindi copia e incolla questa stringa:

-mavx -mavx2 -mfma -msse4.2

(L'opzione predefinita ha causato errori, così come alcune delle altre bandiere. Non ho riscontrato errori con le bandiere sopra. A proposito ho risposto na tutte le altre domande)

Dopo l'installazione, verifico uno speedup da ~ 2x a 2,5x durante l'allenamento di modelli profondi rispetto a un'altra installazione basata sulle ruote predefinite - Installazione di TensorFlow su macOS

Spero che sia d'aiuto

L'ho installato di recente dalla fonte e sotto sono tutti i passaggi necessari per installarlo dalla fonte con le istruzioni menzionate disponibili.

Altre risposte descrivono già perché vengono visualizzati quei messaggi. La mia risposta fornisce una procedura dettagliata su come installare, il che può aiutare le persone a lottare per l'installazione reale come ho fatto io.

1. Installa Bazel

Scaricalo da una delle loro versioni disponibili , ad esempio 0.5.2 . Estrarlo, andare nella directory e configurarlo: bash ./compile.sh. Copia l'eseguibile in /usr/local/bin:sudo cp ./output/bazel /usr/local/bin

2. Installa Tensorflow

Clone tensorflow: git clone https://github.com/tensorflow/tensorflow.git vai alla directory clonata per configurarlo:./configure

Ti verrà chiesto con diverse domande, qui sotto ho suggerito la risposta a ciascuna delle domande, puoi ovviamente scegliere le tue risposte come preferisci:

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. Il pacchetto pip. Per costruirlo devi descrivere quali istruzioni vuoi (sai, quelle Tensorflow hanno informato che ti sei perso).

Crea 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

Crea pacchetto pip: bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

Installa il pacchetto pip Tensorflow che hai appena creato: sudo pip install /tmp/tensorflow_pkg/tensorflow-1.2.1-cp27-cp27mu-linux_x86_64.whl

Ora la prossima volta che avvierai Tensorflow non si lamenterà più delle istruzioni mancanti.

Questo è il metodo più semplice. Solo un passo.

Ha un impatto significativo sulla velocità. Nel mio caso, il tempo impiegato per un passo di allenamento è quasi dimezzato.

Consulta le build personalizzate di tensorflow

Ho compilato un piccolo script Bash per Mac (facilmente trasportabile su Linux) per recuperare tutte le funzionalità della CPU e applicarne alcune per creare TF. Im su TF Master e uso un po 'spesso (un paio di volte in un mese).

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

Per compilare TensorFlow con SSE4.2 e AVX, è possibile utilizzare direttamente

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 SOLUZIONE COMPATIBILE:

Eseguire i comandi seguenti in Terminale (Linux / MacOS) o nel Prompt dei comandi (Windows) per installare Tensorflow 2.0 utilizzando 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

Quando costruisci TensorFlow dalla fonte, eseguirai lo configurescript. Una delle domande poste dallo configurescript è la seguente:

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

Lo configurescript allega i flag specificati al comando bazel che crea il pacchetto pip TensorFlow. In linea di massima, è possibile rispondere a questa richiesta in due modi:

• Se stai costruendo TensorFlow sullo stesso tipo di tipo di CPU di quello su cui eseguirai TensorFlow, allora dovresti accettare il default ( -march=native). Questa opzione ottimizzerà il codice generato per il tipo di CPU della tua macchina.
• Se stai costruendo TensorFlow su un tipo di CPU ma eseguirai TensorFlow su un diverso tipo di CPU, allora considera di fornire un flag di ottimizzazione più specifico come descritto nella documentazione di gcc .

Dopo aver configurato TensorFlow come descritto nell'elenco puntato precedente, dovresti essere in grado di creare TensorFlow completamente ottimizzato per la CPU di destinazione semplicemente aggiungendo il --config=optflag a qualsiasi comando bazel che stai eseguendo.

Per nascondere tali avvisi, è possibile farlo prima del codice effettivo.

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