Comment compiler Tensorflow avec les instructions SSE4.2 et AVX?

Voici le message reçu lors de l'exécution d'un script pour vérifier si Tensorflow fonctionne:

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

J'ai remarqué qu'il a mentionné SSE4.2 et AVX,

1. Que sont SSE4.2 et AVX?
2. Comment ces SSE4.2 et AVX améliorent-ils les calculs CPU pour les tâches Tensorflow?
3. Comment faire compiler Tensorflow en utilisant les deux bibliothèques?

Je viens de rencontrer ce même problème, il semble que la suggestion de Yaroslav Bulatov ne couvre pas le support SSE4.2, l'ajout --copt=-msse4.2suffirait. Au final, j'ai réussi à construire avec

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

sans aucun avertissement ni erreur.

Le meilleur choix pour tout système est probablement:

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

( Mise à jour: les scripts de construction peuvent manger-march=native , peut-être parce qu'ils contiennent un= .)

-mfpmath=bothne fonctionne qu'avec gcc, pas clang. -mfpmath=sseest probablement aussi bonne, sinon meilleure, et est la valeur par défaut pour x86-64. Les versions 32 bits ont la valeur par défaut -mfpmath=387, donc changer cela aidera pour 32 bits. (Mais si vous voulez des performances élevées pour le calcul des nombres, vous devez créer des binaires 64 bits.)

Je ne suis pas sûr de ce que le défaut de tensorflow pour -O2ou -O3est. gcc -O3permet une optimisation complète, y compris la vectorisation automatique, mais cela peut parfois ralentir le code.

Ce que cela fait: --coptforbazel build transmet une option directement à gcc pour la compilation de fichiers C et C ++ (mais pas de liaison, vous avez donc besoin d'une option différente pour l'optimisation de la durée de liaison entre les fichiers)

x86-64 gcc utilise par défaut uniquement des instructions SSE2 ou SIMD plus anciennes, vous pouvez donc exécuter les binaires sur n'importe quel système x86-64. (Voir https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html ). Ce n'est pas ce que tu veux. Vous voulez créer un binaire qui tire parti de toutes les instructions que votre processeur peut exécuter, car vous n'exécutez ce binaire que sur le système sur lequel vous l'avez construit.

-march=nativeactive toutes les options prises en charge par votre processeur, ce qui le rend -mavx512f -mavx2 -mavx -mfma -msse4.2redondant. (Aussi, -mavx2permet déjà -mavxet -msse4.2, donc le commandement de Yaroslav aurait dû être bien). De plus, si vous utilisez un processeur qui ne prend pas en charge l'une de ces options (comme FMA), l'utilisation -mfmarendrait un binaire défectueux avec des instructions illégales.

Par ./configuredéfaut , TensorFlow est activé-march=native , donc son utilisation devrait éviter d'avoir à spécifier manuellement les options du compilateur.

-march=nativeactive -mtune=native, de sorte qu'il optimise votre processeur pour des choses comme la séquence d'instructions AVX qui convient le mieux aux charges non alignées.

Tout cela s'applique à gcc, clang ou ICC. (Pour ICC, vous pouvez utiliser à la -xHOSTplace de -march=native.)

Commençons par expliquer pourquoi voyez-vous ces avertissements en premier lieu .

Vous n'avez probablement pas installé TF depuis la source et au lieu de cela, vous avez utilisé quelque chose comme pip install tensorflow. Cela signifie que vous avez installé des binaires pré-construits (par quelqu'un d'autre) qui n'étaient pas optimisés pour votre architecture. Et ces avertissements vous disent exactement ceci: quelque chose est disponible sur votre architecture, mais il ne sera pas utilisé car le binaire n'a pas été compilé avec. Voici la partie de la documentation .

TensorFlow vérifie au démarrage s'il a été compilé avec les optimisations disponibles sur le CPU. Si les optimisations ne sont pas incluses, TensorFlow émettra des avertissements, par exemple des instructions AVX, AVX2 et FMA non incluses.

La bonne chose est que très probablement vous voulez juste apprendre / expérimenter avec TF donc tout fonctionnera correctement et vous ne devriez pas vous en soucier

Que sont SSE4.2 et AVX?

Wikipedia a une bonne explication sur SSE4.2 et AVX . Cette connaissance n'est pas requise pour être bon en apprentissage automatique. Vous pouvez les considérer comme un ensemble d' instructions supplémentaires permettant à un ordinateur d'utiliser plusieurs points de données par rapport à une seule instruction pour effectuer des opérations qui peuvent être naturellement parallélisées (par exemple, en ajoutant deux tableaux).

Les deux SSE et AVX sont la mise en œuvre d'une idée abstraite de SIMD (instruction unique, données multiples), qui est

une classe d'ordinateurs parallèles dans la taxonomie de Flynn. Il décrit les ordinateurs avec plusieurs éléments de traitement qui effectuent la même opération sur plusieurs points de données simultanément. Ainsi, ces machines exploitent le parallélisme au niveau des données, mais pas la concurrence: il y a des calculs simultanés (parallèles), mais seulement un seul processus (instruction) à un moment donné

C'est suffisant pour répondre à votre prochaine question.

Comment ces SSE4.2 et AVX améliorent-ils les calculs CPU pour les tâches TF

Ils permettent un calcul plus efficace de diverses opérations vectorielles (matrice / tensor). Vous pouvez en lire plus dans ces diapositives

Comment faire compiler Tensorflow en utilisant les deux bibliothèques?

Vous devez avoir un binaire qui a été compilé pour tirer parti de ces instructions. Le moyen le plus simple est de le compiler vous-même . Comme Mike et Yaroslav l'ont suggéré, vous pouvez utiliser la commande bazel suivante

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

Permettez-moi de répondre d'abord à votre troisième question:

Si vous souhaitez exécuter une version auto-compilée dans un conda-env, vous le pouvez. Ce sont les instructions générales que j'exécute pour que tensorflow s'installe sur mon système avec des instructions supplémentaires. Remarque: Cette version était pour une version AMD A10-7850 (vérifiez votre CPU pour quelles instructions sont prises en charge ... cela peut différer) exécutant Ubuntu 16.04 LTS. J'utilise Python 3.5 dans mon conda-env. Nous remercions la page d'installation de la source tensorflow et les réponses fournies ci-dessus.

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.

Quant à votre 2e question:

Une version auto-compilée avec des optimisations vaut bien l'effort à mon avis. Sur ma configuration particulière, les calculs qui prenaient auparavant 560 à 600 secondes ne prennent maintenant qu'environ 300 secondes! Bien que les chiffres exacts varient, je pense que vous pouvez vous attendre à une augmentation de la vitesse de 35 à 50% en général sur votre configuration particulière.

Enfin votre 1ère question:

De nombreuses réponses ont déjà été fournies ci-dessus. Pour résumer: AVX , SSE4.1, SSE4.2 , MFA sont différents types de jeux d'instructions étendues sur les processeurs X86. Beaucoup contiennent des instructions optimisées pour le traitement des opérations matricielles ou vectorielles.

Je vais mettre en évidence ma propre idée fausse pour, espérons-le, vous faire gagner du temps: ce n'est pas que SSE4.2 est une version plus récente des instructions remplaçant SSE4.1. SSE4 = SSE4.1 (un ensemble de 47 instructions) + SSE4.2 (un ensemble de 7 instructions).

Dans le contexte de la compilation tensorflow, si votre ordinateur prend en charge AVX2 et AVX et SSE4.1 et SSE4.2, vous devez placer ces indicateurs d'optimisation pour tous. Ne faites pas comme je l'ai fait et allez simplement avec SSE4.2 en pensant qu'il est plus récent et devrait remplacer SSE4.1. C'est clairement faux! J'ai dû recompiler à cause de cela qui m'a coûté 40 bonnes minutes.

Ce sont des jeux d'instructions de traitement vectoriel SIMD .

L'utilisation d'instructions vectorielles est plus rapide pour de nombreuses tâches; l'apprentissage automatique est une telle tâche.

Citant les documents d'installation de tensorflow :

Pour être compatible avec une gamme de machines aussi large que possible, TensorFlow utilise par défaut uniquement les instructions SSE4.1 SIMD sur les machines x86. La plupart des PC et Mac modernes prennent en charge des instructions plus avancées, donc si vous construisez un binaire que vous exécuterez uniquement sur votre propre machine, vous pouvez les activer en utilisant --copt=-march=nativedans votre commande bazel build.

Grâce à toutes ces réponses + quelques essais et erreurs, j'ai réussi à l'installer sur un Mac avec clang. Il suffit donc de partager ma solution au cas où elle serait utile à quelqu'un.

1. Suivez les instructions de la documentation - Installation de TensorFlow à partir de sources

2. Lorsque vous y êtes invité

   Veuillez spécifier les indicateurs d'optimisation à utiliser pendant la compilation lorsque l'option bazel "--config = opt" est spécifiée [La valeur par défaut est -march = native]

puis copiez-collez cette chaîne:

-mavx -mavx2 -mfma -msse4.2

(L'option par défaut a causé des erreurs, tout comme certains des autres drapeaux. Je n'ai eu aucune erreur avec les drapeaux ci-dessus. BTW, j'ai répondu nà toutes les autres questions)

Après l'installation, je vérifie une accélération de ~ 2x à 2.5x lors de la formation de modèles profonds par rapport à une autre installation basée sur les roues par défaut - Installation de TensorFlow sur macOS

J'espère que ça aide

Je l'ai récemment installé à partir de la source et ci-dessous sont toutes les étapes nécessaires pour l'installer à partir de la source avec les instructions mentionnées disponibles.

D'autres réponses décrivent déjà pourquoi ces messages sont affichés. Ma réponse donne une étape par étape sur la façon d'installer isnstall, ce qui peut aider les gens à se débattre sur l'installation réelle comme je l'ai fait.

1. Installer Bazel

Téléchargez-le depuis l'une de leurs versions disponibles , par exemple 0.5.2 . Extrait, allez dans le répertoire et le configurer: bash ./compile.sh. Copiez l'exécutable dans /usr/local/bin:sudo cp ./output/bazel /usr/local/bin

2. Installer Tensorflow

Clone tensorflow: git clone https://github.com/tensorflow/tensorflow.git Accédez au répertoire cloné pour le configurer:./configure

Cela vous demandera plusieurs questions, ci-dessous j'ai suggéré la réponse à chacune des questions, vous pouvez, bien sûr, choisir vos propres réponses selon vos préférences:

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. Le paquet pip. Pour le construire, vous devez décrire les instructions que vous souhaitez (vous savez, ces Tensorflow vous ont informé que vous manquiez).

Créer un 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

Construire le paquet pip: bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

Installez le package pip Tensorflow que vous venez de créer: sudo pip install /tmp/tensorflow_pkg/tensorflow-1.2.1-cp27-cp27mu-linux_x86_64.whl

La prochaine fois que vous lancerez Tensorflow, il ne se plaindra plus des instructions manquantes.

C'est la méthode la plus simple. Une seule étape.

Il a un impact significatif sur la vitesse. Dans mon cas, le temps pris pour une étape de formation a presque diminué de moitié.

Référencer des versions personnalisées de tensorflow

J'ai compilé un petit script Bash pour Mac (peut facilement être porté sur Linux) pour récupérer toutes les fonctionnalités du CPU et en appliquer certaines pour construire TF. Im sur TF master et utilisez un peu souvent (quelques fois en un mois).

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

Pour compiler TensorFlow avec SSE4.2 et AVX, vous pouvez utiliser directement

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

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

2.0 SOLUTION COMPATIBLE:

Exécutez les commandes ci-dessous dans Terminal (Linux / MacOS) ou dans l'invite de commandes (Windows) pour installer Tensorflow 2.0 à l'aide de 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

Lors de la création de TensorFlow à partir de la source, vous exécuterez le configurescript. L'une des questions que le configurescript pose est la suivante:

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

Le configurescript attachera les indicateurs que vous spécifiez à la commande bazel qui crée le package pip TensorFlow. D'une manière générale, vous pouvez répondre à cette invite de deux manières:

• Si vous construisez TensorFlow sur le même type de type de processeur que celui sur lequel vous exécuterez TensorFlow, vous devez accepter la valeur par défaut ( -march=native). Cette option optimisera le code généré pour le type de CPU de votre machine.
• Si vous construisez TensorFlow sur un type de CPU mais exécuterez TensorFlow sur un autre type de CPU, alors envisagez de fournir un indicateur d'optimisation plus spécifique comme décrit dans la documentation gcc .

Après avoir configuré TensorFlow comme décrit dans la liste à puces précédente, vous devriez être en mesure de créer TensorFlow entièrement optimisé pour le CPU cible simplement en ajoutant l' --config=optindicateur à n'importe quelle commande bazel que vous exécutez.

Pour masquer ces avertissements, vous pouvez le faire avant votre code réel.

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