Deep learning sur serveurs GPU-FIP

Benoit Favre, Stephane Ayache

17 septembre 2018

1 Infos sur les serveurs

Pour mémoire, les slides se trouvent à cette adresse : https://docs.google.com/presentation/
d/1_0hIhvVqxSZqUGaQ_hhUwV_EeDR_3WliZtBVEh9dIG8/edit?usp=sharing

2 TP sans virtualisation
Le plus simple est de faire les TP sans virtualisation. La seule restriction est que l’on a pas accès
en root.

Mise en place Il est important d’assigner à chaque étudiant un nom d’hôte et un numéro de port
pour faire tourner jupyter. Par exemple :
Nom Hote GPU Port
Étudiant 1 gt-0 GPU-0 8000
Étudiant 2 gt-0 GPU-0 8001
Étudiant 3 gt-0 GPU-1 8002
Étudiant 4 gt-0 GPU-1 8003
Étudiant 5 gt-1 GPU-0 8004
Étudiant 6 gt-1 GPU-1 8005
Étudiant 7 gt-1 GPU-0 8006
Étudiant 8 gt-1 GPU-1 8007

Par exemple, ici nous sommes l’Étudiant 6 qui utilise gt-1, le GPU 1 et le port 8006.

Connection SSH On se connecte en ssh sur l’hôte en créant un tunnel pour pouvoir accéder au
notebook jupyter.
ssh -L8006:localhost:8006 etudiant6@gt-1.luminy.univ-amu.fr

Attention, on se fait bannir après 3 erreurs de mot de passe. Il faut utiliser une autre machine pour
se connecter.

Environnement virtuel Le mieux est de créer un environnement virtuel python pour la matière
ou par TP. Créer un environnement virtuel 1 , qu’on nommera par exemple DEEP et l’activer :

virtualenv -p python3 DEEP --system-site-packages

source tp1.venv/bin/activate
1. Ne pas utiliser python2

1
 L’option --system-site-packages sert à utiliser le Tensorflow compilé par la DOSI.
Après, il est possible d’installer des paquets avec pip.

pip install keras sklearn

Désactiver l’environnement virtuel lorsque l’on a fini l’installation de packages :

deactivate

Choix du GPU On peut choisir le GPU sur lequel seront executés les calculs avec la variable
d’environnement CUDA_VISIBLE_DEVICES. Certains toolkits ne prennent pas en compte cette variable
(mais Tensorflow oui). L’étudiant 6 utilise le GPU 1 :

export CUDA_VISIBLE_DEVICES=1

Notebook On peut alors lancer un serveur de notebooks jupyter sur le port choisi (8006). Le tunnel
ssh va du port 8006 sur la machine d’où on s’est connecté vers le port 8006 sur localhost de la machine
distante. C’est là que devra attendre jupyter.

jupyter-notebook --port 8006 --no-browser

Notez que le script jupyter-notebook utilise bien python3 par défaut. Plus tard, le serveur note-
book pourra être arrêté avec ctrl-c.

Notebook dans le navigateur Ouvrir le navigateur sur la machine d’origine à l’adresse http:
//localhost:8006, puis créer un nouveau notebook python3.
Dans une première cellule, on configure le notebook pour qu’il reconnaisse notre environnement
virtuel :

import sys
venv_root = "/amuhome/<login>/.../DEEP" # A modifier !!
sys.path.append(venv_root+"/lib/python3.5/site-packages")

Dans une autre cellule, on peut vérifier l’état du GPU :

!nvidia-smi

Puis on peut configurer tensorflow pour qu’il utilise la moitié de la mémoire du GPU :
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.5
set_session(tf.Session(config=config))
Ceci permettra à un autre étudiant d’utiliser ce GPU en même temps. Si on revérifie l’état du GPU
avec nvidia-smi, on voit que la moitié de la mémoire du GPU 1 est allouée.
La suite ressemble à n’importe quel TP de deep learning.

2
3 TP avec virtualisation
Conteneur Nous allons créer un conteneur LXC avec 32GB de disque, sur l’hôte gt-1, à partir du
template debian9-nvidia390-cuda9.1.tar.gz, pour l’utilisateur favre.b (utiliser le votre), avec 16G
de mémoire, le nom tp1, un bon mot de passe root 2 et aucun swap.

sudo dositools createct -d 32 -h 1 -i debian9-nvidia390-cuda9.1.tar.gz -l favre.b -m 16384 -n tp1 -p

Cette commande prend du temps. On peut obtenir le numéro de ce conteneur avec la commande
suivante :

sudo dositools list

Ici, le conteneur a le numéro 33082. Ce numéro permet de l’identifier et correspond aussi à son
adresse ip. On le lance avec la commande suivante :
sudo dositools start -v 33082
L’adresse ip correspondant au 33082 est 139.124.33.82. On peut faire un ssh en root dessus avec le
mot de passe défini à la création :
ssh root@139.124.33.82
Une fois connecté, on est comme dans une machine virtuelle en root, avec accès aux GPU. Le
système est minimal mais on peut utiliser apt-get pour ajouter des paquets.

Serveur de notebooks Par exemple, créons 3 un serveur de jupyter notebooks multiutilisateurs.

Les utilisateurs qui ont un compte dans le conteneur pourront s’y connecter sans passer par ssh.
Tout d’abord, il faut créer des comptes pour ces utilisateurs, par exemple :
useradd etudiant6
Puis installer les dépendences de jupyterhub :
apt -y install python3-pip curl build-essential libssl-dev
curl -sL https://deb.nodesource.com/setup_6.x | bash
apt install nodejs npm
npm install -g configurable-http-proxy
Et jupyterhub lui-même :
pip3 install jupyterhub
pip3 install --upgrade notebook
Le serveur est lancé de la manière suivante :
jupyterhub --no-ssl --ip 0.0.0.0 --port 8000
Ce serveur attend à l’adresse 139.124.33.82 :8000. Malheureusement cette adresse est rendue innaxes-
sible par le firewall AMU. Il faut donc que les étudiants se connectent comme pour le TP sans virtua-
lisation avec ssh en faisant un tunnel vers cette adresse :

ssh -L8000:139.124.33.82:8000 etudiant6@gt-1.luminy.univ-amu.fr

En ouvrant un navigateur sur http://localhost:8000, l’étudiant verra une fenêtre de login où il
devra entrer ses identifiants tels que définis avec adduser. Il peut ensuite créer à loisir des notebooks
dans le système fichier local du conteneur.
2. Générés par exemple avec https://passwordsgenerator.net/.
3. Fondé sur https://github.com/jupyterhub/jupyterhub/wiki/Installation-of-Jupyterhub-on-remote-server.

3
4 Lancer des jobs ”longs” sur un serveur du département
Il sera certainement nécessaire de faire tourner des jobs pendant plusieurs heures, par exemple pour
l’entrainement de réseaux sur des corpus volumineux.

Pour cela, pas question d’attendre devant jupyter, on utilisera la commande screen depuis le ser-
veur. screen lance une ”console virtuelle”, elle permet d’ouvrir plusieurs consoles depuis la même
fenêtre, de passer de l’une à l’autre et surtout de continuer l’exécution d’un programme même après
déconnexion du serveur. Voici les principales instructions screen à connaı̂tre :

$ screen Démarre une nouvelle console virtuelle

$ screen -r [pid] se reconnecte à une console virtuelle
Ctrl+a+d Détache la console virtuelle (se déconnecte et laisse tourner le job)
Ctrl+a+c Créé une nouvelle fenêtre virtuelle
Ctrl+a+w Liste les fenêtres virtuelles ouvertes
Ctrl+a+1 Passe à la deuxième fenêtre virtuelle..

5 Utilisation de la plateforme Colab de Google

En complément des ressources existantes au département, ceux qui le souhaite pourront utiliser le
service Colab récemment introduit par Google : https://colab.research.google.com.

Colab permet l’exécution jusqu’à 24h consécutives de notebooks jupyter sur des serveurs mis à
disposition par Google. Les notebooks seront à placer dans un Google Drive, ainsi que tous les fichiers
utilisés dans le notebook (ie : le dataset). Les sorties du programme sont aussi stockées sur le Google
Drive (attention donc à ne pas lire/écrire de données trop volumineuses). Pour choisir l’accélération
matérielle GPU, rendez-vous dans le menu Modifier/Paramètres du notebook...