Applications et Guides

Intel Habana Gaudi 2 : installation et test

Avant de commencer à installer le logiciel d'accélération Gaudi 2, il y a une caractéristique importante qui mérite d'être mentionnée. Nous sommes habitués au fait que l'entraînement et l'inférence des réseaux neuronaux peuvent être réalisés à l'aide de GPU. Cependant, Intel Habana Gaudi 2 est très différent des GPU et représente une classe différente de dispositifs conçus uniquement pour accélérer les tâches d'IA.

De nombreuses applications et cadres familiers ne fonctionneront pas sans une préparation préalable du système d'exploitation et, dans certains cas, sans un kit d'outils de migration GPU spécial. Cela explique le grand nombre d'étapes préparatoires que nous décrivons dans cet article. Commençons dans l'ordre.

Étape 1. Installer la pile logicielle SynapseAI

Pour commencer à travailler avec les accélérateurs Intel Habana Gaudi 2, vous devez installer la pile logicielle SynapseAI. Elle comprend un compilateur graphique spécial qui transforme la topologie du modèle de réseau neuronal pour optimiser efficacement l'exécution sur l'architecture Gaudi, des bibliothèques API pour la mise à l'échelle horizontale, ainsi qu'un SDK distinct pour la création d'algorithmes et de modèles d'apprentissage automatique de haute performance.

Séparément, nous notons que SynapseAI est la partie qui vous permet de créer un pont entre les cadres populaires tels que PyTorch/TensorFlow et les accélérateurs d'IA de Gaudi 2. Cela vous permet de travailler avec des abstractions familières, et Gaudi 2 optimise indépendamment les calculs. Les opérateurs spécifiques pour lesquels les accélérateurs n'ont pas de support matériel sont exécutés sur le CPU.

Pour simplifier l'installation des composants individuels de SynapseAI, un script shell pratique a été créé. Téléchargez-le :

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Rendez le fichier exécutable :

chmod +x habanalabs-installer.sh

Exécuter le script :

./habanalabs-installer.sh install --type base

Suivez les invites du système pendant l'installation. Vous trouverez un rapport détaillé dans le fichier journal. Vous pouvez y voir quels paquets ont été installés et si les accélérateurs ont été trouvés et initialisés avec succès.

Les journaux sont ici : /var/log/habana_logs/install-YYYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Tout comme l'utilitaire nvidia-smi fournit des informations sur les GPU installés et les processus de calcul en cours, SynapseAI dispose d'un programme similaire. Vous pouvez le lancer pour obtenir un rapport sur l'état actuel des accélérateurs d'IA Gaudi 2 :

hl-smi

Étape 2. Test TensorFlow

TensorFlow est l'une des plateformes les plus populaires pour l'apprentissage automatique. En utilisant le même script d'installation, vous pouvez installer une version préconstruite de TensorFlow avec le support des accélérateurs Gaudi 2. Commençons par installer les dépendances générales :

./habanalabs-installer.sh install -t dependencies

Ensuite, nous allons installer les dépendances pour TensorFlow :

./habanalabs-installer.sh install -t dependencies-tensorflow

Installer la plateforme TensorFlow dans un environnement virtuel implémenté à l'aide du mécanisme Python Virtual Environment (venv) :

./habanalabs-installer.sh install --type tensorflow --venv

Activons l'environnement virtuel créé :

source habanalabs-venv/bin/activate

Créer un exemple de code Python simple qui utilisera les capacités des accélérateurs Gaudi 2 :

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Enfin, exécutez l'application :

python3 example.py

Pour quitter l'environnement virtuel, exécutez la commande suivante :

deactivate

Étape 3. Cloner le référentiel de formation

Cloner le référentiel avec le code MLperf :

git clone https://github.com/mlcommons/training_results_v3.0

Créer un répertoire séparé qui sera utilisé par le conteneur Docker avec MLperf :

mkdir -p mlperf

Modifier le répertoire :

cd mlperf

Exportons quelques variables d'environnement :

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Créez de nouveaux répertoires en utilisant les variables créées :

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Copier l'application benchmark dans $MLPERF_DIR/Habana :

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Exporter une autre variable qui contiendra un lien pour télécharger la version désirée du conteneur Docker :

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Étape 4. Installer Docker

Notre instance fonctionne sous Ubuntu Linux 22.04 LTS et ne supporte pas Docker par défaut. Donc, avant de télécharger et d'exécuter des conteneurs, vous devez installer le support Docker. Rafraîchissons le cache des paquets et installons quelques paquets de base dont vous aurez besoin plus tard :

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Pour installer Docker, vous devez ajouter un dépôt de projet signé numériquement. Téléchargez la clé de signature numérique et ajoutez-la au magasin de clés du système d'exploitation :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker peut fonctionner sur des plateformes aux architectures diverses. La commande suivante détectera l'architecture de votre serveur et ajoutera la ligne de dépôt correspondante à la liste du gestionnaire de paquets APT :

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Mettez à jour le cache des paquets et les politiques et installez docker-ce (Docker Community Edition) :

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Enfin, vérifiez que le démon Docker est opérationnel :

sudo systemctl status docker

Étape 5. Exécuter le conteneur Docker

Lançons le conteneur en mode privilégié en utilisant les variables spécifiées précédemment :

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Pour plus de commodité, vous pouvez accéder au terminal à l'intérieur du conteneur via SSH :

sudo docker exec mlperf3.0 bash -c "service ssh start"

Pour ouvrir un shell de commande (bash) dans la session en cours, exécutez la commande suivante :

sudo docker exec -it mlperf3.0 bash

Étape 6. Préparer un jeu de données

Pour exécuter les tests d'implémentation de Bert à partir de MLperf, vous avez besoin d'un jeu de données préparé. La meilleure méthode consiste à générer un jeu de données à partir de données préchargées. Le référentiel MLperf comprend un script spécial, prepare_data.sh, qui nécessite un ensemble spécifique de paquets pour fonctionner. Naviguons vers le répertoire suivant :

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Installer tous les paquets nécessaires en utilisant la liste pré-générée et le gestionnaire de paquets pip :

pip install -r requirements.txt

Définissez la variable PYTORCH_BERT_DATA pour indiquer au script où stocker les données :

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Exécutez le script :

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

La procédure de génération est assez longue et peut prendre plusieurs heures. Soyez patient et n'interrompez pas le processus. Si vous prévoyez de vous déconnecter de la session SSH, il est recommandé d'utiliser l'utilitaire screen immédiatement avant de démarrer le conteneur Docker.

Étape 7. Emballer l'ensemble de données

L'étape suivante consiste à "découper" l'ensemble de données en morceaux égaux pour le lancement ultérieur de MLperf. Créons un répertoire séparé pour les données empaquetées :

mkdir $PYTORCH_BERT_DATA/packed

Exécuter le script d'emballage :

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Étape 8. Exécuter un test

Maintenant que l'ensemble de données est préparé, il est temps d'exécuter le test. Cependant, il est impossible de le faire sans préparation préalable. Les auteurs du test de Bert ont laissé quelques valeurs codées en dur dans le script, qui vont interférer avec l'exécution du test. Tout d'abord, renommez le répertoire suivant :

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Changez le répertoire :

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

L'éditeur GNU Nano n'étant pas installé dans le conteneur, il doit être installé séparément. Vous pouvez également utiliser l'éditeur Vi intégré :

apt update && apt -y install nano

Maintenant, éditez le script de lancement du test :

nano launch_bert_pytorch.sh

Trouvez la première ligne :

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Remplacer par ce qui suit :

DATA_ROOT=/root/datasets/pytorch_bert

Trouvez la deuxième ligne :

INPUT_DIR=$DATA_ROOT/packed

Remplacer par ce qui suit :

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Enregistrer le fichier et quitter.

Le code du test comprend une fonction de limitation qui empêche le gradient de dépasser certaines valeurs, prévenant ainsi une croissance exponentielle potentielle. Pour des raisons qui nous sont inconnues, cette fonction est absente de la version de PyTorch utilisée dans le conteneur, ce qui fait que le test se termine anormalement pendant la phase d'échauffement.

Une solution potentielle pourrait être de supprimer temporairement cette fonction du code du fichier fastddp.py. Pour ce faire, ouvrez le fichier :

nano ../PyTorch/fastddp.py

Trouvez et commentez les trois lignes de code suivantes en utilisant le # (symbole shebang) de manière à ce qu'elles ressemblent à ceci :

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Enregistrez également le fichier et quittez. Changez de répertoire :

cd ../HLS-Gaudi2-PT

Enfin, exécutez le script. L'exécution prendra environ 20 minutes :

./launch_bert_pytorch.sh

Voir aussi:

Mis à jour: 12.08.2025

Publié: 23.01.2025