Neural Network Intelligence (NNI)

NNI est une boîte à outils pour l'optimisation des hyper-paramètres afin d'obtenir des réseaux de neurones performants.

Une documentation très complète est disponible (doc).

Cette page Wiki regroupe nos expériences sur l'installation (NNI, Pytorch, Anaconda) et l'exécution (GPU, ssh, interface Web usager) de NNI.

* L'installation requiert Python>=3.6. Il est possible de faire l'installation directement avec git en utilisant le code source de NNI sur Github et en lançant le script d'installation :

git clone -b v1.9 https://github.com/Microsoft/nni.git

cd nni

./install.sh

• Tutoriel pytorch, un framework pour l'apprentissage machine (réseaux de neurones et apprentissage profond).
• Commande (shell) pour examiner l'utilisation du GPU : nvidia-smi
• Pour accéder aux GPUs sur pandora il faut specifier une variable d'environnement : export MKL_THREADING_LAYER=GNU
• Pour des évaluations sur un ou plusieurs GPUs, il faut faire : export CUDA_VISIBLE_DEVICES=x,y,z
• Pour accéder à l'interface Web de NNI sur une machine distante, on peut utiliser un tunnel ssh (port 8080) vers les machines du GERAD avec VPN (tunnelblick ou openVPN) : ssh -L 8080:localhost:8080 [email protected].
• Il est possible de procéder sans VPN : chercher ssh hop tunneling sur le web.
• Pour le VPN, voir le site d'aide du GERAD.

• Pour vérifier l'installation de NNI, l'aide suggère un example basé sur la base de donnée MNIST et tensorflow. Pour ma part je n'ai pas réussi à le faire fonctionner.
• Je recommande de faire un test utilisant la base de donnée d'images cifar10 (chat, bateau, avions, etc.) et pytorch (ou mnist et pytorch).
• Avant de lancer l'optimisation des hyperparamètres, on doit disposer de pytorch. Le plus simple est de procéder avec anaconda. Au GERAD, on peut charger anaconda sur nos machines. Par la suite on active l'environnement pytorch-1.6.0 qui est disponible au GERAD:

module load anaconda

conda activate pytorch-1.6.0

• Avant de lancer l'optimisation, on peut tester une évaluation simple. On se déplace dans le répertoire nni/examples/trials/cifar10-pytorch. On doit modifier le fichier main.py pour spécifier des valeurs des hyperparamètres. Créons un fichier main_test.py à partir de main.py. Pour cela, on trouve dans le fichier les lignes suivantes :

RCV_CONFIG = nni.get_next_parameter()

#RCV_CONFIG = {'lr': 0.1, 'optimizer': 'Adam', 'model':'senet18'}

On doit commenter (#) la première ligne et dé-commenter la deuxième. Je recommande aussi de faire un premier test avec un nombre réduit d'epochs. Dans la partie 'main' du script python on remplace le défaut de 200 epochs par 5.

parser.add_argument(“–epochs”, type=int, default=200) =⇒ parser.add_argument(“–epochs”, type=int, default=5)

• Lorsque l'on lance la commande python3 main_test.py on obtient :

=⇒ Preparing data..

.. ..

=⇒ Building model..

Epoch: 0

Le script ne fait pas utilisation de GPU (sinon on aurait une mention de CUDA) et on remarque que c'est très long car on utilise le CPU! Nous devons faire 2 commandes supplémentaires pour pouvoir utiliser les GPU avant de relancer le script:

export MKL_THREADING_LAYER=GNU

export CUDA_VISIBLE_DEVICES=x

Pour choisir la valeur de x, on fait la commande nvidia-smi pour voir quels sont les GPU disponibles.

• Une fois que notre test préliminaire est concluant, on peut lancer l'optimisation, il faut créer une “expérience” à partir d'un ficher de configuration au format YAML :

nnictl create –config nni/examples/trials/cifar10-pytorch/config.yml

• Dans le fichier de configuration, on retrouve plusieurs informations. Le fichier de définition des variables au format JSON doit être fourni :

searchSpacePath: search_space.json

• Le fichier json précise le nom, le type et les valeurs possibles pour les variables.

{ “lr”:{“_type”:“choice”, “_value”:[0.1, 0.01, 0.001, 0.0001]}, “optimizer”:{“_type”:“choice”, “_value”:[“SGD”, “Adadelta”, “Adagrad”, “Adam”, “Adamax”]}, “model”:{“_type”:“choice”, “_value”:[“vgg”, “resnet18”, “googlenet”, “densenet121”, “mobilenet”, “dpn92”, “senet18”]} }

• Dans cet exemple, on a choix de modèles de réseaux de neurones qui sont prédéfinis, ce qui permet d'avoir des performances très élevées.

• Dans NNI, l'optimiseur des hyperparamètres est appelé “tuner” (j'imagine que c'est pour ne pas confondre avec l'optimiseur qui modifie les poids du réseau de neurones). Le choix se fait dans le fichier de configuration. Plusieurs tuners sont disponibles : https://nni.readthedocs.io/en/v1.6/Tuner/BuiltinTuner.html.
• Le fichier de configuration doit aussi préciser comment effectuer les évaluations (l'équivalent de notre BB_EXE). Il faut fournir la commande pour lancer le script python : python3 main.py
• Il y une série de commande nnictl dans le shell pour controller les expériences effectuées avec NNI. Parmi les commandes, celles que j'utilise le plus :

nnictl create pour créer une expérience.

nnictl top pour voir ce qui se passe dans l'expérience en cours.

nnictl stop pour arrêter une expérience en cours.

• Au début d'une expérience, NNI va créer un répertoire contenant tous les logs du tuner et les fichiers produits par les évaluations. Par défaut, ce répertoire se trouve dans ~/nni-experiments et porte comme nom l'identifiant de l'expérience (id). Cet identifiant est donné lorsque l'on créé un expérience. On peut modifier ce répertoire en rajoutant la ligne suivante dans le fichier config.yml :

logDir: /home/username/mon_repertoire_adore/NNI/nni-experiments

• Une fois qu'une expérience est lancée sur une machine distante on peut visualiser ce qui se passe à partir de notre machine locale. Si ce n'est pas déjà fait, on se connecte par ssh et on créé un tunnel entre les ports 8080 (par défaut) de la machine locale et la machine distante (voir plus haut). On démarre notre fureteur préféré et on entre l'adresse localhost:8080. Magie, magie, normalement on devrait voir une page web avec ce qui se passe dans notre expérience.

• Éditer le fichier YAML (config.yml)
• Pour faire plusieurs évaluations en parallèle, on met trialConcurrency: x
• Chaque évaluation peut être effectuée sur plusieurs GPU (à tester); pour utiliser un seul GPU, dans la section “trials” on rajoute gpuNum: 1
• Je n'ai pas eu de succès en spécifiant les GPU disponibles dans la section “localConfig”, avec gpuIndices: 0,1,2,3.
• En définissant la variable d'environnement CUDA_VISIBLE_DEVICES on peut spécifier quelles GPU utiliser : export CUDA_VISIBLE_DEVICES=0,1,2,3