====== Neural Network Intelligence (NNI) ======

[[https://github.com/microsoft/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 ([[https://nni.readthedocs.io/en/latest/index.html|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. 

**N'HÉSITEZ PAS À COLLABORER AVEC VOS PROPRES EXPÉRIENCES**

Une [[[[https://youtu.be/nm7v5Bgx164|vidéo d'un mini-tutoriel]] basé sur un premier essai est disponible.

==== L'installation est facile ====
* [[https://nni.readthedocs.io/en/latest/Tutorial/InstallationLinux.html#installation|L'installation]] requiert Python>=3.6. Il est possible de faire l'installation directement avec git en utilisant le code source de NNI sur [[https://github.com/Microsoft/nni.git|Github]] et en lançant le script d'installation : 

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

==== Quelques trucs en vrac pour commencer ====

  * [[https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html|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''; En direct: ''watch -d -n 0.5 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** ([[https://www.gerad.ca/aide/doku.php?id=fr:acces-exterieur-vpn|tunnelblick ou openVPN]]) : ''ssh -L 8080:localhost:8080 username@pandora.gerad.lan''.
  * Il est possible de procéder sans VPN en faisant un 'saut' par ''ssh.gerad.ca'' : chercher ''ssh hop tunneling'' sur le web.
  * Pour le VPN, voir le site d'aide du GERAD.

==== Tester NNI  ====
  * 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 conda 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 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'' et faisons quelques modifications. 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 quelles 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 a une série de commandes ''nnictl'' dans le shell pour controller les expériences effectuées avec NNI. Parmi les [[https://nni.readthedocs.io/en/v1.6/Tutorial/Nnictl.html?highlight=commands|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é sur la machine locale 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.
==== Utiliser plusieurs GPUs avec NNI  ====

  * É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 GPUs (à tester); pour utiliser une seule GPU, dans la section "trials", on rajoute ''gpuNum: 1''
  * Je n'ai pas eu de succès en spécifiant les GPUs 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 GPUs utiliser : ''export CUDA_VISIBLE_DEVICES=0,1,2,3''

==== Paralléliser une évaluation sur plusieurs GPUs ====

Quelques petites choses sur l'évaluation avec plusieurs GPUs toujours en définissant correctement la variable d'environnement ''CUDA_VISIBLE_DEVICES''. Les tests ont été fait sur ''pandora''. 

  * J’ai fait roulé ce [[https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html#create-model-and-dataparallel|test]] sur un modèle simple et utilisant ''PyTorch.'' J'observe que c'est plus lent avec 2 GPUs qu'avec un seul. Oups!
  * J’ai fait un test avec cifar100 et resnet101. Sur un GPU cela occupe ~ 9GB, chaque epoch prend ~ 2'30". Sur deux GPUs, c’est 4-5 GB par GPU et chaque epoch prend ~ 1'50". Sur trois GPUs, c’est 3-4 GB par GPU et chaque epoch prend 1'30". Le speedup n’est pas génial mais avec des modèles plus gros ça doit valoir la peine.
  * Ma conclusion c’est que pytorch peut gérer plusieurs GPUs sans que l’on ait grand chose à faire mais il faut que le réseau soit assez gros. Dans mon cas, pour cifar10 avec resnet18, cela ne vaut pas la peine et je suis mieux de paralléliser les blocs d’évaluations.
  * Les tests précédents on été obtenu avec un ''batch size'' de 128. On peut changer ce paramètre qui influence la taille des batchs d'images qui sont envoyés vers un GPU. Dans ''pytorch'' on peut modifier comment le ''trainset'' est chargé.

''trainset = torchvision.datasets.CIFAR100(root='./data', train=True, download=True, transform=transform_train)''

''trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) ''

  * Sur les quelques tests que j'ai fait, le nombre de workers ne semble pas avoir d'influence. Par contre le batch size a un effet : batch_size=128 avec 1 GPU: 2'30"/epoch et avec 2 GPUs: 1'50'‘/epoch, batch_size=256 avec 2 GPUs : 1’25'’/epoch, batch_size=3*128 avec 3 GPUs : 1'/epoch.