TensorFlow avec accélération GPU

Exploitez le plein potentiel de TensorFlow avec notre guide de démarrage pour application GPU.

TensorFlow

TensorFlow est une bibliothèque logicielle pour la conception et le déploiement de simulations numériques, plus spécifiquement avec les applications d’apprentissage automatique. Cette bibliothèque permet d’utiliser des algorithmes pour l’exécution d’opérations connectées sur une gamme étendue de plateformes accélérées par GPU – des appareils mobiles aux stations de travail fixes en passant par les serveurs haut de gamme.

TensorFlow s’exécute jusqu’à 50% plus vite grâce aux nouveaux GPU Pascal et offre d’importants gains de performance sur les nœuds à GPU multiples. Vous pouvez désormais entraîner vos modèles en quelques heures, contre plusieurs jours auparavant.

Installation

Configuration requise

L'accélération GPU de TensorFlow requiert les composants suivants :

  • Système d'exploitation Linux 64 bits
  • Python 2.7
  • CUDA 7.5 (CUDA 8.0 requis pour les GPU à architecture Pascal)
  • cuDNN v5.1 (cuDNN v6 avec TF v1.3)

 

Vous devez également disposer d’un GPU NVIDIA compatible avec les capacités de calcul  3.0 ou plus.

Instructions de téléchargement et d’installation

TensorFlow est désormais distribué sous licence open source Apache v2 via GitHub. Ce guide détaille l’installation et la configuration de TensorFlow sur une machine Ubuntu 16.04 avec un ou plusieurs GPU NVIDIA.

Le site Internet de TensorFlow est une excellente ressource pour savoir comment procéder à l’installation dans un environnement virtuel, avec Docker ou à partir des fichiers source des versions les plus récentes.

VOUS TROUVEREZ CI-DESSOUS UNE SYNTHÈSE DE LA PROCÉDURE DE COMPILATION

1. Installez/mettez à jour vos pilotes NVIDIA.

Veillez à utiliser les pilotes NVIDIA les plus récents pour votre système.

$ sudo add-apt-repository ppa:graphics-drivers/ppa 
$ sudo apt update (répétez la procédure si un message d’erreur ou d’avertissement s’affiche) 
$ sudo apt-get install nvidia- (appuyez sur Tab pour accéder à la version la plus récente). 375 (n’utilisez pas la version 378, qui peut provoquer des erreurs de connexion)

Redémarrez votre système pour activer les pilotes graphiques.

2. Installez/testez CUDA.

Pour utiliser TensorFlow avec des GPU NVIDIA, vous devez commencer par installer le  Kit d’outils NVIDIA CUDA . Veuillez trouver ci-dessous les références d’installation avec CUDA 8.0.

Connectez-vous sur https://developer.nvidia.com/cuda-downloads

Sélectionnez Linux, x86_64, Ubuntu, 16.04, deb (local).
$ sudo dpkg -i cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64.deb (il s’agit du fichier deb que vous avez téléchargé) 
$ sudo apt-get update
$ sudo apt-get install cuda

Si un message s’affiche pour vous suggérer d’exécuter à nouveau "sudo apt-get update", faites-le puis exécutez la commande "sudo apt-get install cuda".

$ export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}} 
$ export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64\${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Testez votre installation de CUDA :

$ cd /usr/local/cuda-8.0/samples/5_Simulations/nbody
$ sudo make
$ ./nbody

Une nouvelle fenêtre doit ensuite s’ouvrir pour vous proposer d’exécuter une simulation n-body.

3. Installez cuDNN.

Une fois le Kit d'outils CUDA installé, veuillez télécharger la bibliothèque cuDNN v5.1 (cuDNN v6 avec TF v1.3) pour Linux et procédez à l’installation en suivant la documentation officielle. (Remarque : vous devrez vous enregistrer au programme de développeurs pour le calcul accéléré). Veuillez trouver ci-dessous les références d’installation avec cuDNN v5.1.

Une fois la bibliothèque téléchargée, veuillez accéder au répertoire qui contient cuDNN :

$ tar -xzvf cudnn-8.0-linux-x64-v5.1.tgz
$ sudo cp cuda/include/cudnn.h /usr/local/cuda/include
$ sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
$ sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

Remarque : les étapes ci-dessus sont identiques pour cuDNN v6.

Une fois ces pré-requis installés, vous pouvez configurer et installer TensorFlow.

4. Préparez les dépendances de TensorFlow et les packs requis.

$ sudo apt-get install libcupti-dev

5. Installez TensorFlow (version avec accélération GPU)

$ pip install tensorflow-gpu

6. Vérifiez la réussite de votre installation.

Commencez par vérifier la bonne réussite de votre installation en fermant tous les terminaux ouverts puis en ouvrant un nouveau terminal.

Changez le répertoire (cd) en sélectionnant n’importe quel répertoire de votre système autre que le sous-répertoire de tensorflow à partir duquel vous avez invoqué la commande de configuration.

Invoquez python: type python par ligne de commande.

Saisissez le programme suivant :

$ import tensorflow as tf
$ hello = tf.constant('Hello, TensorFlow!')
$ sess = tf.Session()
$ print(sess.run(hello))

Le message "Hello, TensorFlow!" doit normalement s’afficher. Félicitations ! Vous pouvez également saisir "print(tf.__version__)" pour vérifier la version de TensorFlow qui a été installée.

Entraînement de modèles

TensorFlow peut être utilisé via Python ou des API C++ et ses fonctionnalités-clés sont exploitables avec un backend C++. L’API fournit une interface de manipulation des tenseurs (réseaux à N dimensions) similaire à Numpy et inclut des capacités de différenciation automatique pour les gradients de calcul destinés aux routines d’optimisation.

La bibliothèque propose une vaste sélection d’opérations intégrées (multiplication matricielle, convolutions, fonctions de regroupement et d’activation, fonctions de perte, optimiseurs et bien d’autres opérations). Une fois un graphe de calcul défini, TensorFlow permet d’assurer efficacement son exécution sur une station de travail de bureau, un serveur ou des plateformes mobiles.

Pour exécuter les codes ci-dessous, veuillez accéder à votre répertoire TensorFlow 1 :

$ cd (tensorflow directory) 
$ git clone -b update-models-1.0 https://github.com/tensorflow/models

La reconnaissance d’images est l’un des champs d’application préférentiels du Deep Learning. Malgré tout, et même si le cerveau humain est capable de reconnaître des images de manière naturelle, cette tâche peut s’avérer bien plus difficile pour un système informatique. Les avancées récentes de l’apprentissage automatique permettent aujourd’hui d’égaler les capacités humaines - voire de les surpasser - grâce notamment aux réseaux de neurones convolutifs (CNN) et aux nouveaux systèmes de vision par ordinateur appuyés par des benchmarks comme ImageNet .

DÉMONSTRATION RAPIDE AVEC INCEPTION-V3

Commençons par exécuter les commandes suivantes pour mettre à profit la vision par ordinateur :

$ cd (tensorflow directory)/models/tutorials/image/imagenet
$ python classify_image.py

La commande "classify_image.py" permet de télécharger le modèle entraîné avec Inception-v3 à partir de tensorflow.org lors de l’exécution initiale du programme. Vous devez disposer d’environ 200 Mo d’espace libre sur votre disque dur. Cette commande permet de procéder à une classification à partir de l’image d’un panda (disponible dans "/tmp/imagenet/cropped_panda.jpg"). L’exécution fructueuse du modèle fournira les résultats suivants :

giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca (score = 0.89107)
indri, indris, Indri indri, Indri brevicaudatus (score = 0.00779)
lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens (score = 0.00296)
custard apple (score = 0.00147)
earthstar (score = 0.00117)

Vous pouvez également tester des images JPEG en utilisant l’argument "--image_file" :

$ python classify_image.py --image_file <path to the JPEG file> 
(e.g. python classify_image.py --image_file /tmp/imagenet/cropped_pand.jpg)

CIFAR-10

La classification CIFAR-10 est une tâche de benchmark fréquemment utilisée pour l’apprentissage automatique. Cette tâche permet de classer des images RGB 32x32 dans 10 catégories (avion, automobile, oiseau, chat, cerf, chien, grenouille, cheval, bateau et camion).

Ce modèle utilise l’architecture de référence conçue par Alex Krizhevsky, avec quelques différences mineures au niveau des couches supérieures. Cette architecture multicouches comprend une succession de convolutions et de non-linéarités suivies par des couches entièrement connectées avec une classification de type softmax.

Commençons par entraîner notre modèle.

$ cd (tensorflow directory)/models/tutorials/image/cifar10
$ python cifar10_train.py

Un message de confirmation et les valeurs suivantes doivent normalement s’afficher :

Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
…… 
2017-03-06 14:59:09.089282: step 10230, loss = 2.12 (1809.1 examples/sec; 0.071 sec/batch)
2017-03-06 14:59:09.760439: step 10240, loss = 2.12 (1902.4 examples/sec; 0.067 sec/batch)
2017-03-06 14:59:10.417867: step 10250, loss = 2.02 (1931.8 examples/sec; 0.066 sec/batch)
2017-03-06 14:59:11.097919: step 10260, loss = 2.04 (1900.3 examples/sec; 0.067 sec/batch)
2017-03-06 14:59:11.754801: step 10270, loss = 2.05 (1919.6 examples/sec; 0.067 sec/batch)
2017-03-06 14:59:12.416152: step 10280, loss = 2.08 (1942.0 examples/sec; 0.066 sec/batch)
……

Félicitations, vous avez commencé à entraîner votre premier modèle !

Vous pouvez ensuite évaluer les performances du modèle que vous avez entraîné. Pour ce faire, utilisez le script "cifar10_eval.py script". La précision sera évaluée avec une valeur de 1, qui correspond au nombre de fois où la prédiction correspond précisément au descriptif de l’image.

$ python cifar10_eval.py

Un message de ce type s’affiche ensuite :

2017-03-06 15:34:27.604924: precision @ 1 = 0.499

UTILISATION D’UN RÉSEAU INCEPTION V3 PRÉ-ENTRAÎNÉ AVEC UN NOUVEAU JEU DE DONNÉES

Nous allons maintenant utiliser Inception v3 de Google pour mettre en place un cas d’utilisation avancé. Inception v3 est un réseau convolutif de pointe conçu pour la classification d’images. L’entraînement initial de ce modèle peut s’avérer très intense et peut nécessiter plusieurs jours, voire des semaines entières. Une approche alternative consiste à télécharger le modèle pré-entraîné puis à le réutiliser pour un autre jeu de données. Un jeu de données contenant des images de fleurs sera utilisé pour ré-entraîner le réseau.

Téléchargez le jeu de données :

$ cd ~
$ curl -O http://download.tensorflow.org/example_images/flower_photos.tgz
$ tar xzf flower_photos.tgz
$ cd (tensorflow directory where you git clone from master)
$ python configure.py

Remarque : vous pouvez conserver les options par défaut. Saisissez le numéro de version approprié de cuDNN et/ou CUDA si vous possédez des versions autres que celles suggérées par défaut par le configurateur.

$ python tensorflow/examples/image_retraining/retrain.py --image_dir ~/flower_photos

Remarque :

  • Si le message "...libstdc++.so.6: version `CXXABI_1.3.8' not found…" s’affiche, saisissez la commande suivante : "cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 /home/ /anaconda3/lib/ ".
  • Si le message "...import error: no module named autograd…" s’affiche, saisissez la commande suivante : "pip install autograd".

Utilisez le modèle ré-entraîné:

$ bazel build tensorflow/examples/image_retraining:label_image && \
bazel-bin/tensorflow/examples/image_retraining/label_image \
--graph=/tmp/output_graph.pb --labels=/tmp/output_labels.txt \
--output_layer=final_result:0 \
--image=$HOME/flower_photos/daisy/21652746_cc379e0eea_m.jpg

Le script d’évaluation affichera des résultats de ce type (en spécifiant la précision de la classification) :

daisy (score = 0.99735)
sunflowers (score = 0.00193)
dandelion (score = 0.00059)
tulips (score = 0.00009)
roses (score = 0.00004)

Pour de plus amples informations sur l’utilisation du modèle Inception v3, veuillez consulter le didacticiel.

Benchmarks

Chacun des modèles décrits dans la section précédente peut être défini par son temps d’exécution par minibatch ou sa vitesse moyenne d’exemples par seconde (qui peut être convertie en temps d’exécution par minibatch en la divisant à la taille du batch). Le graphique ci-après présente les performances attendues sur un système équipé de GPU NVIDIA.

data-center-gpu-ready-app-tensorflow-chart-cifar10-843-u

IMAGES ENTRAÎNÉES PAR SECONDE AVEC
INCEPTION V3 SUR DES GPU MULTIPLES

Le modèle Inception v3 prend également en charge l’entraînement de GPU multiples. Le graphique ci-après présente les performances attendues avec 1, 2 et 4 GPU Tesla par nœud.

Benchmark TensorFlow Inception

Configuration système recommandée

Configuration matérielle

PC

Parameter
Specs

CPU Architecture

x86_64

System Memory

8-32GB

CPUs

1

GPU Model

NVIDIA®TITAN X (Pascal)

GPUs

1-2

Servers

Parameter
Specs

CPU Architecture

x86_64

System Memory

32 GB

CPUs/Node

1-2

GPU Model

Tesla® P40 and P100

GPUs/Node

1-4

Configuration logicielle

Software stack

Parameter
Version

OS

Unbuntu 14.04

GPU Driver

352.68 or newer

CUDA Toolkit

8.0 or newer

cuDNN Library

v5.0 or newer

Python

2.7

Déployez votre solution GPU personnalisée.