Apps & Gidsen

Intel Habana Gaudi 2: installeren en testen

Voordat je begint met het installeren van de Gaudi 2 accelerators software, is er één belangrijke functie die het vermelden waard is. We zijn gewend aan het feit dat training en inferentie van neurale netwerken kan worden uitgevoerd met behulp van GPU's. Intel Habana Gaudi 2 is echter heel anders dan GPU's en vertegenwoordigt een andere klasse apparaten die uitsluitend zijn ontworpen voor het versnellen van AI-taken.

Veel bekende toepassingen en frameworks zullen niet werken zonder eerst het besturingssysteem voor te bereiden en, in sommige gevallen, zonder een speciale GPU Migration Toolkit. Dit verklaart het grote aantal voorbereidende stappen die we in dit artikel beschrijven. Laten we in volgorde beginnen.

Stap 1. SynapseAI Software Stack installeren

Om aan de slag te gaan met Intel Habana Gaudi 2 versnellers, moet u de SynapseAI stack installeren. Deze bevat een speciale grafiekcompiler die de topologie van het neurale netwerkmodel transformeert om de uitvoering op de Gaudi-architectuur effectief te optimaliseren, API-bibliotheken voor horizontale schaling en een aparte SDK voor het maken van krachtige algoritmen en modellen voor machinaal leren.

Apart vermelden we dat SynapseAI het onderdeel is waarmee je een brug kunt slaan tussen populaire frameworks zoals PyTorch/TensorFlow en de Gaudi 2 AI-versnellers. Hierdoor kun je werken met bekende abstracties, en Gaudi 2 optimaliseert zelfstandig berekeningen Specifieke operatoren waarvoor versnellers geen hardware-ondersteuning hebben, worden uitgevoerd op de CPU.

Om de installatie van individuele SynapseAI componenten te vereenvoudigen, is er een handig shellscript gemaakt. Laten we het downloaden:

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

Maak het bestand uitvoerbaar:

chmod +x habanalabs-installer.sh

Voer het script uit:

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

Volg de aanwijzingen van het systeem tijdens de installatie. Je vindt een gedetailleerd rapport in het logbestand. Hierin kun je zien welke pakketten zijn geïnstalleerd en of de versnellers met succes zijn gevonden en geïnitialiseerd.

Logs hier: /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

Net zoals het nvidia-smi hulpprogramma informatie geeft over geïnstalleerde GPU's en draaiende rekenprocessen, heeft SynapseAI een vergelijkbaar programma. Je kunt het draaien om een rapport te krijgen over de huidige staat van de Gaudi 2 AI versnellers:

hl-smi

Stap 2. TensorFlow test

TensorFlow is een van de populairste platforms voor machinaal leren. Met hetzelfde installatiescript kunt u een vooraf gebouwde versie van TensorFlow installeren met ondersteuning voor Gaudi 2-acceleratoren. Laten we beginnen met het installeren van de algemene afhankelijkheden:

./habanalabs-installer.sh install -t dependencies

Vervolgens installeren we de afhankelijkheden voor TensorFlow:

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

Installeer het TensorFlow platform in een virtuele omgeving die geïmplementeerd is met behulp van het Python Virtual Environment (venv) mechanisme:

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

Laten we de gecreëerde virtuele omgeving activeren:

source habanalabs-venv/bin/activate

Maak een eenvoudig Python-codevoorbeeld dat gebruikmaakt van de mogelijkheden van de Gaudi 2-versnellers:

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()

Voer tot slot de toepassing uit:

python3 example.py

Voer het volgende commando uit om de virtuele omgeving af te sluiten:

deactivate

Stap 3. Trainingsarchief klonen

Kloon het archief met de MLperf code:

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

Maak een aparte map die gebruikt zal worden door de Docker container met MLperf:

mkdir -p mlperf

Wijzig de directory:

cd mlperf

Laten we enkele omgevingsvariabelen exporteren:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Maak nieuwe mappen aan met de aangemaakte variabelen:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Kopieer de benchmark app naar $MLPERF_DIR/Habana:

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

Exporteer een andere variabele die een link opslaat om de gewenste versie van de Docker-container te downloaden:

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

Stap 4. Docker installeren

Onze instantie draait Ubuntu Linux 22.04 LTS en ondersteunt Docker niet standaard. Dus voordat je containers kunt downloaden en uitvoeren, moet je Docker-ondersteuning installeren. Laten we de pakketcache verversen en een aantal basispakketten installeren die je later nodig hebt:

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

Om Docker te installeren, moet je een digitaal ondertekende projectrepository toevoegen. Download de digitale handtekeningsleutel en voeg deze toe aan de sleutelopslag van het besturingssysteem:

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

Docker kan draaien op platformen met verschillende architecturen. Het volgende commando detecteert de architectuur van je server en voegt de overeenkomstige repository regel toe aan de APT package manager lijst:

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

Werk de pakketcache en het beleid bij en installeer docker-ce (Docker Community Edition):

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

Controleer tot slot of de Docker daemon draait:

sudo systemctl status docker

Stap 5. Docker-container uitvoeren

Laten we de container starten in bevoorrechte modus met behulp van de eerder opgegeven variabelen:

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

Voor het gemak kun je via SSH toegang krijgen tot de terminal in de container:

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

Voer het volgende commando uit om een commandoshell (bash) te openen in de huidige sessie:

sudo docker exec -it mlperf3.0 bash

Stap 6. Een dataset voorbereiden

Om Bert implementatietests uit te voeren vanuit MLperf, hebt u een voorbereide dataset nodig. De optimale methode is om een dataset te genereren van vooraf geladen gegevens. De MLperf-repository bevat een speciaal script, prepare_data.sh, dat een specifieke set pakketten nodig heeft om te functioneren. Laten we naar de volgende directory navigeren:

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

Installeer alle vereiste pakketten met behulp van de vooraf gegenereerde lijst en de pip package manager:

pip install -r requirements.txt

Stel de PYTORCH_BERT_DATA variabele in om het script te instrueren waar de gegevens opgeslagen moeten worden:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Voer het script uit:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

De generatieprocedure duurt vrij lang en kan enkele uren in beslag nemen. Wees geduldig en onderbreek het proces niet. Als je van plan bent om de verbinding met de SSH-sessie te verbreken, is het aan te raden om het schermhulpprogramma te gebruiken vlak voordat je de Docker-container start.

Stap 7. De dataset verpakken

De volgende stap is het "knippen" van de dataset in gelijke stukken voor de daaropvolgende lancering van MLperf. Laten we een aparte map maken voor ingepakte gegevens:

mkdir $PYTORCH_BERT_DATA/packed

Voer het verpakkingsscript uit:

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

Stap 8. Voer een test uit

Nu de dataset is voorbereid, is het tijd om de test uit te voeren. Het is echter onmogelijk om dit te doen zonder voorafgaande voorbereiding. De auteurs van de Bert-test hebben een aantal hardgecodeerde waarden in het script laten staan, die de uitvoering van de test zullen verstoren. Hernoem eerst de volgende directory:

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Wijzig de directory:

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

Omdat de GNU Nano editor niet in de container is geïnstalleerd, moet deze apart worden geïnstalleerd. Als alternatief kunt u de ingebouwde Vi editor gebruiken:

apt update && apt -y install nano

Bewerk nu het testscript:

nano launch_bert_pytorch.sh

Zoek de eerste regel:

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

Vervang door het volgende:

DATA_ROOT=/root/datasets/pytorch_bert

Zoek de tweede regel:

INPUT_DIR=$DATA_ROOT/packed

Vervang door het volgende:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Sla het bestand op en sluit af.

De testcode bevat een begrenzingsfunctie die ervoor zorgt dat de gradiënt bepaalde waarden niet overschrijdt, waardoor potentiële exponentiële groei wordt voorkomen. Om ons onbekende redenen is deze functie afwezig in de PyTorch-versie die wordt gebruikt in de container, waardoor de test abnormaal eindigt tijdens de opwarmfase.

Een mogelijke oplossing is om deze functie tijdelijk te verwijderen uit de code in het fastddp.py bestand. Open hiervoor het bestand:

nano ../PyTorch/fastddp.py

Zoek en becommentarieer de volgende drie regels code met behulp van het # (shebang symbool) zodat ze er als volgt uitzien:

#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))

Sla ook het bestand op en sluit af. Verander de map:

cd ../HLS-Gaudi2-PT

Voer tot slot het script uit. Het zal ongeveer 20 minuten duren om te voltooien:

./launch_bert_pytorch.sh

Zie ook:

Bijgewerkt: 12.08.2025

Gepubliceerd: 23.01.2025