Tutoriel Apprentissage machine

This article is a draft

This is not a complete article: This is a draft, a work in progress that is intended to be published into an article, which may or may not be ready for inclusion in the main wiki. It should not necessarily be considered factual or authoritative.

Cette page constitue un guide de démarrage servant à porter une tâche d'apprentissage automatique (Machine Learning) sur une grappe Calcul Canada.

Étape 1: Archivage d'un ensemble de données

Les systèmes de fichiers gérés par Calcul Canada sont conçus pour fonctionner avec une quantité limitée de gros fichiers. Assurez-vous que l'ensemble de données dont vous aurez besoin pour votre entraînement se trouve dans un fichier archive (tel que "tar"), que vous transférerez sur votre nœud de calcul au début de votre tâche. Si vous ne le faites pas, vous risquez de causer des lectures de fichiers à haute fréquence du noeud de stockage vers votre nœud de calcul, nuisant ainsi à la performance globale du système. Si vous voulez apprendre davantage sur la gestion des grands ensembles de fichiers, on vous recommande la lecture de cette page.

En supposant que les fichiers dont vous avez besoin sont dans le dossier mydataset:

$ tar cf mydataset.tar mydataset/*

La commande ci-haut ne compresse pas les données. Si vous croyez que ce serait approprié, vous pouvez utiliser tar czf.

Étape 2: Préparation de l'environnement virtuel

Nous vous recommandons d'essayer votre tâche dans une tâche interactive avant de la soumettre avec un script (section suivante). Vous pourrez ainsi diagnostiquer plus rapidement les problèmes. Voici un exemple de la commande pour soumettre une tâche interactive:

$ salloc --account=def-someuser --gres=gpu:1 --cpus-per-task=6 --mem=32000M --time=1:00

Une fois dans la tâche:

• Créez et activez un environnement virtuel dans $SLURM_TMPDIR (cette variable pointe vers un dossier local, c'est-à-dire sur le nœud de calcul). N'utilisez pas Anaconda. Par exemple:

$ virtualenv --no-download $SLURM_TMPDIR/env

• Installez les paquets dont vous avez besoin. Pour TensorFlow, installez le paquet tensorflow_gpu; il s'agit d'une version optimisée pour nos systèmes.
• Tentez d'exécuter votre programme
• Installez les paquets manquants s'il y a lieu
• Créez un fichier requirements.txt afin de pouvoir recréer l'environnement virtuel:

(env) $ pip freeze > ~/requirements.txt

Maintenant est un bon moment pour vérifier que votre tâche lit et écrit le plus possible sur le nœud de calcul ($SLURM_TMPDIR), et le moins possible sur les systèmes de fichiers partagés (home, scratch, project).

Étape 3: Préparation du script de soumission

Vous devez soumettre vos tâches à l'aide de scripts sbatch, afin qu'elles puissent être entièrement automatisées. Les tâches interactives servent uniquement à préparer et à déboguer des tâches.

Éléments importants d'un script sbatch

1. Compte sur lequel les ressources seront "facturées"
2. Ressources demandées:
   1. Nombre de CPU, suggestion: 6
   2. Nombre de GPU, suggestion: 1 (Utilisez un (1) seul GPU, à moins d'être certain que votre programme en utilise plusieurs. Par défaut, TensorFlow et PyTorch utilisent un seul GPU.)
   3. Quantité de mémoire, suggestion: 32000M
   4. Durée (Maximum Béluga: 7 jours, Graham et Cedar: 28 jours)
3. Commandes bash:
   1. Préparation de l'environnement (modules, virtualenv)
   2. Transfert des données vers le noeud de calcul
   3. Lancement de l'exécutable

Exemple de script

File : ml-test.sh

#!/bin/bash
#SBATCH --gres=gpu:1       # Request GPU "generic resources"
#SBATCH --cpus-per-task=6  # Cores proportional to GPUs: 6 on Cedar, 16 on Graham.
#SBATCH --mem=32000M       # Memory proportional to GPUs: 32000 Cedar, 64000 Graham.
#SBATCH --time=0-03:00     # DD-HH:MM:SS
#SBATCH --output=%N-%j.out

module load python/3.6 cuda cudnn

SOURCEDIR=~/ml-test

# Prepare virtualenv
virtualenv --no-download $SLURM_TMPDIR/env
source $SLURM_TMPDIR/env/bin/activate
pip install --no-index -r $SOURCEDIR/requirements.txt

# Prepare data
mkdir $SLURM_TMPDIR/data
tar xf ~/projects/def-xxxx/data.tar $SLURM_TMPDIR/data

# Start training
python $SOURCEDIR/train.py $SLURM_TMPDIR/data

Morcellement d'une longue tâche

Nous vous recommandons de morceler vos tâches en blocs de 24 heures. Demander des tâches plus courtes améliore votre priorité. En créant une chaîne de tâches, il est possible de dépasser la limite de 7 jours sur Béluga.

1. Modifiez votre script de soumission (ou votre programme) afin que votre tâche puisse être interrompue et continuée. Votre programme doit pouvoir accéder au checkpoint le plus récent. (Voir l'exemple de script ci-dessous.)
2. Vérifiez combien d'epochs (ou d'itérations) peuvent être effectuées à l'intérieur de 24 heures.
3. Calculez combien de blocs de 24 heures vous aurez besoin: n_blocs = n_epochs_total / n_epochs_par_24h
4. Utilisez l'argument --array 1-<n_blocs>%1 pour demander une chaine de n_blocs tâches.

Le script de soumission ressemblera à ceci:

File : ml-test-chain.sh

#!/bin/bash
#SBATCH --array=1-10%1   # 10 is the number of jobs in the chain
#SBATCH ...

module load python/3.6 cuda cudnn

# Prepare virtualenv
...

# Prepare data
...

# Get most recent checkpoint (this example is for PyTorch *.pth checkpoint files)
export CHECKPOINTS=~/scratch/checkpoints/ml-test
LAST_CHECKPOINT=$(find . -maxdepth 1 -name "$CHECKPOINTS/*.pth" -print0 | xargs -r -0 ls -1 -t | head -1)

# Start training
if [ -n "$LAST_CHECKPOINT" ]; then
    # $LAST_CHECKPOINT is null; start from scratch
    python $SOURCEDIR/train.py --write-checkpoints-to $CHECKPOINTS ...
else
    python $SOURCEDIR/train.py --load-checkpoint $CHECKPOINTS/$LAST_CHECKPOINT --write-checkpoints-to $CHECKPOINTS ...
fi